Sqlite issues with Xamarin, Mono.Data.Sqlite, and System.Data

_readme.md

##We're having issues with our Sqlite PCL Project.

####The issues

1. Anywhere that references Mono.Data.Sqlite.SqliteConnection shows the following error.

Module 'System, Version 4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' should be referenced.

2. Anything trying to use File.Exists is showing a compiler error

Cannot resolve symbol 'File'

####The particulars

We're using .NET Portable Subset 158
C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETPortable\v4.0\Profile\Profile158\

We've included

Mono.Data.Sqlite 
    - C:\Program Files (x86)\Mono-3.2.3\lib\mono\4.5\Mono.Data.Sqlite.dll
System.Data
    - C:\Program Files (x86)\Mono-3.2.3\lib\mono\4.5\System.Data.dll

I have no idea where to go from here.

DbConnectionProvider.cs

using System;
using Mono.Data.Sqlite;

namespace OurApplication.AppCore.Data.Sqlite
{
    public class DbConnectionProvider : IDbConnectionProvider
    {
        private readonly string _connectionString;

        public DbConnectionProvider(string sqliteDatabasePath, string databaseName)
        {
            // the sqliteDatabasePath is hard coded in 'Data.Sqlite.DbProvider'
            //     _sqliteDatabasePath = "{0}.sqlite3";
            _connectionString = string.Format("Data Source=" + sqliteDatabasePath, databaseName);
        }

        public SqliteConnection GetOpenConnection()
        {
            var connection = new SqliteConnection(_connectionString);
            if (connection == null) throw new Exception("Could not create a database connection.");

            connection.Open();

            return connection;
        }
    }
}

DbProvider.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Reflection;
using Mono.Data.Sqlite;

namespace OurApplication.AppCore.Data.Sqlite
{
    public class DbProvider : DbProviderBase
    {
        private const string RootSqlScriptPath = "OurApplication.AppCore.Data.Sqlite.SqlScripts.";
        private const string CheckTableExists = "SELECT name FROM sqlite_master WHERE type='table' AND name='{0}'";
        private readonly IDbConnectionProvider _connectionProvider;
        private readonly string _sqliteDatabasePath;

        public DbProvider ( string databaseName )
        {
            DatabaseName = databaseName;
            _sqliteDatabasePath = "{0}.sqlite3";
            _connectionProvider = new DbConnectionProvider( _sqliteDatabasePath, databaseName );
        }

        public override sealed IDialect Dialect { get { return new SqliteDialect(); } }

        public override string LoadSqlFile ( string fileName )
        {
            var sqlStatement = string.Empty;

            using ( var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream( RootSqlScriptPath + fileName ) )
            {
                if ( resourceStream != null )
                {
                    sqlStatement = new StreamReader( resourceStream ).ReadToEnd();
                }
            }

            return sqlStatement;
        }

        public override bool CheckIfDatabaseExists ()
        {
            return File.Exists( string.Format( _sqliteDatabasePath, DatabaseName ) );
        }

        public override void CreateDatabase ()
        {
            Mono.Data.Sqlite.SqliteConnection.CreateFile( DatabaseName );
        }

        public override void DropDatabase ()
        {
            File.Delete( string.Format( _sqliteDatabasePath, DatabaseName ) );
        }

        public override bool CheckIfTableExists ( string tableName )
        {
            var exists = ExecuteScalar<int>( string.Format( CheckTableExists, tableName ) ) == 1;
            return exists;
        }

        #region ExecuteReader

        public override TResult ExecuteReader<TResult> ( string commandText, Func<IDbReader, TResult> readerMapper )
        {
            return ExecuteReader( commandText, new Dictionary<string, object>(), readerMapper );
        }

        public override TResult ExecuteReader<TResult> ( string commandText, IDictionary<string, object> parameters, Func<IDbReader, TResult> readerMapper )
        {
            using ( var connection = _connectionProvider.GetOpenConnection() )
            {
                using ( var command = connection.CreateCommand() )
                {
                    command.CommandType = CommandType.Text;
                    command.CommandText = commandText;
                    foreach ( var parameter in parameters )
                    {
                        command.Parameters.Add( new SqliteParameter( parameter.Key, parameter.Value ?? DBNull.Value ) );
                    }

                    using ( var reader = command.ExecuteReader() )
                    {
                        var r = new DbReader( reader );
                        return readerMapper( r );
                    }
                }
            }
        }

        #endregion

        #region ExecuteNonQuery

        public override void ExecuteNonQuery ( string commandText )
        {
            ExecuteNonQuery( commandText, new Dictionary<string, object>() );
        }

        public override void ExecuteNonQuery ( string commandText, IDictionary<string, object> parameters )
        {
            using ( var connection = _connectionProvider.GetOpenConnection() )
            {
                using ( var command = connection.CreateCommand() )
                {
                    command.CommandType = CommandType.Text;
                    command.CommandText = commandText;
                    foreach ( var parameter in parameters )
                    {
                        command.Parameters.Add( new SqliteParameter( parameter.Key, parameter.Value ?? DBNull.Value ) );
                    }

                    command.ExecuteNonQuery();
                }
            }
        }

        #endregion

        #region ExecuteScalar

        public override TKey ExecuteScalar<TKey> ( string commandText )
        {
            return ExecuteScalar<TKey>( commandText, new Dictionary<string, object>() );
        }

        public override TKey ExecuteScalar<TKey> ( string commandText, IDictionary<string, object> parameters )
        {
            using ( var connection = _connectionProvider.GetOpenConnection() )
            {
                using ( var command = connection.CreateCommand() )
                {
                    command.CommandType = CommandType.Text;
                    command.CommandText = commandText;
                    foreach ( var parameter in parameters )
                    {
                        command.Parameters.Add( new SqliteParameter( parameter.Key, parameter.Value ?? DBNull.Value ) );
                    }

                    var result = command.ExecuteScalar();

                    if( typeof( TKey ) == typeof( Guid ) )
                        return (TKey)(object)new Guid( ( byte[] )result );
                    if( typeof( TKey ) == typeof( int ) )
                        return ( TKey )( object )(result == null ? 0 : 1);

                    return ( TKey )result;
                }
            }
        }

        #endregion
    }
}

DbReader.cs

using System.Collections.Generic;

namespace OurApplication.AppCore.Data.Sqlite
{
    public class DbReader : IDbReader
    {
        private readonly SqliteDataReader _reader;
		private Dictionary<string,int> _hashOfNames;

        public DbReader ( SqliteDataReader reader )
        {
            _reader = reader;
        }

        public void Close ()
        {
            _reader.Close();
        }

        public bool NextResult ()
        {
            return _reader.NextResult();
        }
        public bool Read ()
        {
            return _reader.Read();
        }

        public object this[int index]
        {
            get { return _reader[index]; }
        }

        public object this[string name]
        {
            get { return HasName( name ) ? _reader[name] : null; }
        }

        public int Depth
        {
            get { return _reader.Depth; }
        }

        public bool IsClosed
        {
            get { return _reader.IsClosed; }
        }

        public int RecordsAffected
        {
            get { return _reader.RecordsAffected; }
        }

        private bool HasName ( string name )
        {
            if ( _hashOfNames == null )
            {
				_hashOfNames = new Dictionary<string,int>();
                for ( int i = 0;i < _reader.FieldCount;i++ )
                {
                    _hashOfNames.Add( _reader.GetName( i ), i );
                }
            }
            return _hashOfNames.ContainsKey( name );
        }
    }
}