using (var db = new BloggingContext())
{
  var serviceProvider = db.GetInfrastructure();
  var loggerFactory = serviceProvider.GetService();
  loggerFactory.AddProvider(new MyLoggerProvider());
  //. . .
}

using (var db = new BloggingContext())
{
  db.ConfigureLogging( s => Console.WriteLine(s) );
  //. . .
}

using (var db = new BloggingContext())
{
  db.ConfigureLogging( s => Console.WriteLine(s) , (c,l) => l == LogLevel.Error || c == DbLoggerCategory.Query.Name);
  //. . .
}

using (var db = new BloggingContext())
{
  db.ConfigureLogging(s => Console.WriteLine(s), LoggingCategories.SQL);
  //. . .
}

using Microsoft.Samples.EFLogging;

namespace Microsoft.Samples.EFLogging
{
    using System;
    using Microsoft.EntityFrameworkCore;
    using Microsoft.EntityFrameworkCore.Infrastructure;
    using Microsoft.Extensions.Logging;
    using System.Collections.Concurrent;
    using System.Collections.Generic;


    public enum LoggingCategories
    {
        All = 0,
        SQL = 1
    }

    public static class DbContextLoggingExtensions
    {
        public static void ConfigureLogging(this DbContext db, Action<String> logger, Func<string, LogLevel, bool> filter )
        {
            var serviceProvider = db.GetInfrastructure<IServiceProvider>();
            var loggerFactory = (ILoggerFactory)serviceProvider.GetService(typeof(ILoggerFactory));

            LogProvider.CreateOrModifyLoggerForDbContext(db.GetType(), loggerFactory, logger, filter);
        }
        
        public static void ConfigureLogging(this DbContext db, Action<String> logger, 
                                           LoggingCategories categories = LoggingCategories.All)
        {
            var serviceProvider = db.GetInfrastructure<IServiceProvider>();
            var loggerFactory = (LoggerFactory)serviceProvider.GetService(typeof(ILoggerFactory));

            if (categories == LoggingCategories.SQL)
            {
                var SqlCategories = new List<string> { DbLoggerCategory.Database.Command.Name,
                                                       DbLoggerCategory.Query.Name,
                                                       DbLoggerCategory.Update.Name };
                LogProvider.CreateOrModifyLoggerForDbContext(db.GetType(), 
                                                             loggerFactory, 
                                                             logger, 
                                                             (c, l) => SqlCategories.Contains(c));
            }
            else if (categories == LoggingCategories.All)
            {
                LogProvider.CreateOrModifyLoggerForDbContext(db.GetType(), 
                                                             loggerFactory, logger, 
                                                             (c, l) => true);
            }
        }
    }
    class LogProvider : ILoggerProvider
    {

        //volatile to allow the configuration to be switched without locking
        public volatile LoggingConfiguration Configuration;
        static bool DefaultFilter(string CategoryName, LogLevel level) => true;

        static ConcurrentDictionary<Type, LogProvider> providers = new ConcurrentDictionary<Type, LogProvider>();

        public static void CreateOrModifyLoggerForDbContext(Type DbContextType, 
                                                            ILoggerFactory loggerFactory, 
                                                            Action<string> logger, 
                                                            Func<string, LogLevel, bool> filter = null)
        {
            bool isNew = false;
            var provider = providers.GetOrAdd(DbContextType, t =>
              {
                  var p = new LogProvider(logger, filter ?? DefaultFilter);
                  loggerFactory.AddProvider(p);
                  isNew = true;
                  return p;
               }
              );
            if (!isNew)
            {
                provider.Configuration = new LoggingConfiguration(logger, filter ?? DefaultFilter);
            }
            
        }

        public class LoggingConfiguration
        {
            public LoggingConfiguration(Action<string> logger, Func<string, LogLevel, bool> filter)
            {
                this.logger = logger;
                this.filter = filter;
            }
            public readonly Action<string> logger;
            public readonly Func<string, LogLevel, bool> filter;
        }


        private LogProvider(Action<string> logger, Func<string, LogLevel, bool> filter)
        {
            this.Configuration = new LoggingConfiguration(logger, filter);
        }
   
        public ILogger CreateLogger(string categoryName)
        {
            return new Logger(categoryName, this);
        }

        public void Dispose()
        { }

        private class Logger : ILogger
        {
            
            readonly string categoryName;
            readonly LogProvider provider;
            public Logger(string categoryName, LogProvider provider)
            {
                this.provider = provider;
                this.categoryName = categoryName;
            }
            public bool IsEnabled(LogLevel logLevel)
            {
                return true; 
            }

            public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, 
                                    Exception exception, Func<TState, Exception, string> formatter)
            {
                //grab a reference to the current logger settings for consistency, 
                //and to eliminate the need to block a thread reconfiguring the logger
                var config = provider.Configuration;
                if (config.filter(categoryName, logLevel))
                {
                    config.logger(formatter(state, exception));
                }
            }

            public IDisposable BeginScope<TState>(TState state)
            {
                return null;
            }
        }
    }
}

PS C:\install> dir
    Directory: C:\install
Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----        4/22/2016   5:29 PM                SQLExpress
-a----        4/23/2016   7:42 AM        2380288 foo.bak
-a----        4/23/2016   4:18 PM           2803 InstallSQLExpressAndRestoreDatabase.ps1

#run this script from an elevated command prompt to install SQL Server Express edition and restore 
$ScriptDir = Split-Path $PSCommandPath

#enter database name
$databaseName = "foo"
#enter backup location
$backupLocation = "$ScriptDir\foo.bak"
#enter instance name
$instanceName = "SQLExpress"

#---------------------------------------------------------
#              INSTALL SQL SERVER EXPRESS EDITION
#---------------------------------------------------------

$serviceAccount = "NT Service\MSSQL`$$($instanceName)"
if ($instanceName -eq "MSSQLSERVER")
{
    $serviceAccount = "NT Service\MSSQLSERVER"
}
$cmd  = @"
"$ScriptDir\SqlExpress\setup.exe" /Q /IACCEPTSQLSERVERLICENSETERMS /ACTION=install  /ROLE=AllFeatures_WithDefaults  /INSTANCENAME=$($instanceName) /SQLSVCACCOUNT="$($serviceAccount)"  
"@

write-host "Installing"
write-host $cmd
& cmd.exe /c $cmd

#---------------------------------------------------------
#              RESTORE YOUR DATABASE
#---------------------------------------------------------
$constr = "server=(local)\$instanceName;database=master;integrated security=true"

$sql = @"
select InstanceDefaultDataPath = serverproperty('InstanceDefaultDataPath'),
select InstanceDefaultLogPath = serverproperty('InstanceDefaultLogPath')
"@
$con = new-object system.data.sqlclient.sqlconnection $constr

$handler = [System.Data.SqlClient.SqlInfoMessageEventHandler] {param($s, $a)  
                foreach ($e in $a.Errors) 
                { 
                    write-host "SQL Message (Number: $($e.Number) Severity: $($e.Class) Line Number: $($e.LineNumber)) $($e.Message)" -ForegroundColor Red
                } 
             }; 
$con.add_InfoMessage($handler); 
$con.FireInfoMessageEventOnUserErrors = $true;

$con.Open()
$cmd = $con.CreateCommand()

$cmd.CommandText = "select InstanceDefaultDataPath = serverproperty('InstanceDefaultDataPath')"
$dataDir = $cmd.ExecuteScalar().ToString()

$cmd.CommandText = "select InstanceDefaultDataPath = serverproperty('InstanceDefaultLogPath')"
$logDir = $cmd.ExecuteScalar().ToString()

$cmd.CommandText = "restore filelistonly from disk='$backupFile' with file=1";
$rdr = $cmd.ExecuteReader()
$dt = new-object System.Data.DataTable
$dt.Load($rdr)

$dataFileName =  ($dt.Rows | where Type -EQ D | select -First 1).LogicalName
$logFileName =   ($dt.Rows | where Type -EQ L | select -First 1).LogicalName

$cmd.CommandText = @"

restore database [$databaseName] 
  from disk='$backupLocation'
  with 
   MOVE '$($dataFileName)' TO '$($dataDir)$($dataFileName)_Data.mdf', 
   MOVE '$($logFileName)'  TO '$($dataDir)$($logFileName)_Log.ldf'
"@;
$cmd.CommandText
$cmd.ExecuteNonQuery() | out-null

write-host "Restore complete"
$con.Close()

            var con = new SqlConnection("server=.;Integrated Security=true"); var cb = new SqlConnectionStringBuilder(con.ConnectionString); Console.WriteLine($"TransparentNetworkIPResolution= {cb.TransparentNetworkIPResolution}");

Anyway, here's how to do it.  You can't use SQLNCLI11, and shouldn't use MSDASQL.  If you try to use MSDASQL SQL Server will silently use SQLNCLI11 instead, so that won't work either.  So first you need to install an older version of the SQL Native Client OleDB provider, SQLNCLI10.  It can be installed side-by-side with SQLNCLI11, and is still supported.

So first download the newest SQL Native Client OleDB provider that still supports connecting to SQL 2000, SQLNCLI10 from here:

Microsoft® SQL Server® 2008 R2 SP2 Feature Pack

Then set up the linked server like this, after adjusting the server name in sp_addlinkedserver and the login mapping in sp_addlinkedsrvlogin for your environment.

 EXEC sp_MSset_oledb_prop N'SQLNCLI10', N'AllowInProcess', 1
 GO
 EXEC sp_addlinkedserver @server = N'SQL2000', @srvproduct=N'', @provider=N'SQLNCLI10', @datasrc=N'MySql2000Server'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'collation compatible', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'data access', @optvalue=N'true'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'dist', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'pub', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'rpc', @optvalue=N'true'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'rpc out', @optvalue=N'true'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'sub', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'connect timeout', @optvalue=N'0'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'collation name', @optvalue=null
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'lazy schema validation', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'query timeout', @optvalue=N'0'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'use remote collation', @optvalue=N'true'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'remote proc transaction promotion', @optvalue=N'true'
 GO
 EXEC sp_addlinkedsrvlogin @rmtsrvname = N'SQL2000', @locallogin = NULL , @useself = N'False', @rmtuser = N'dw', @rmtpassword = N'P@ssword'
 GO

Then you can test with a query like

 select * from openquery (sql2000, 'select @@servername a' )
 

David

https://www.nuget.org/packages/Oracle.ManagedDataAccess/

This short post is just because most of the information you will find on this topic is out-of-date.

Oracle finally wrote a 100% managed code ADO.NET provider and it's available on NuGet.  So you can just right-click on your references and grab the NuGet package.  Not install, no bitness headaches.

David

Here's a simple workaround for loading an assembly from an arbitrary location.  The idea is to register an AppDomain.AssemblyResolve event handler.

The .NET Framework provides the AppDomain.AssemblyResolve event for applications that require greater control over assembly loading. By handling this event, your application can load an assembly into the load context from outside the normal probing paths, select which of several assembly versions to load, emit a dynamic assembly and return it, and so on. This topic provides guidance for handling the AssemblyResolve event.

Resolving Assembly Loads

Which does just what we need.  The question is where and how to wire it up.  The trick is to realize that .NET's Just-in-Time (JIT) compilation is responsible for loading dependent assemblies, and therefore guarantees that the assemblies referenced in a type's method won't be loaded until just before the method is executed.  This means that in the type's static constructor we can reliably wire up the AssemblyResolve event that will supply the referenced types.

When you create a SSIS Script Task or Script Component SSIS generates a class for you called ScriptMain, and you can wire-up the event in a Static Constructor for that type.  A Static Constructor is guaranteed to be called exactly once "before the first instance is created or any static members are referenced.", so therefore before the dependent assemblies are loaded.

EG:

[Microsoft.SqlServer.Dts.Tasks.ScriptTask.SSISScriptTaskEntryPointAttribute]
public partial class ScriptMain : Microsoft.SqlServer.Dts.Tasks.ScriptTask.VSTARTScriptObjectModelBase
{
     static ScriptMain()
     {
         AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
     }
     static System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
     {
         if (args.Name.Contains("ssisHelper"))
         {
             string path = @"c:\temp\";
             return System.Reflection.Assembly.LoadFile(System.IO.Path.Combine(path, "ssisHelper.dll"));
         }
         return null;
     }
    . . .

You can then drop the referenced assemblies in a well-known location on the SSIS server, or use a package variable to refer to the location and pass that in to the Script Task or Script Component.

David

It's a single file, and has conditional compilation directives so it works on both kinds of projects.  It uses AES 256-bit encryption and you must share both a 256bit key and an and initialization vector between your two projects.  Typically the IV is shared in code, and the key is acquired at runtime.

The result is a single object called EncDec in the attached EncDec.cs file. that you new-up with the IV and the key, and then use .Encrypt() and .Decrypt(). All data is passed as strings, base64 endoded if needed.

Here’s how to call it

    string plainText = "Hello, World!";
    
    string TestKey = "gFlMfLZu4unBGfBh9weIuLwlcXHSa59vxyUQWM3yh1M=";
    string TestIV = "rRNgGypocle9VG9bth6kxg==";
    
    var ed = new EncDec(TestKey, TestIV);
    
    var cypherText = ed.Encrypt(plainText);
    var plainText2 = ed.Decrypt(cypherText);
    

David

EncDec.cs

ObjectDataReader is intended to be simple and fast.  It uses dynamically-compiled expressions to access the object properties, instead of reflection.  ObjectDataReader differes from the older EntityDataReader primarily by removing support for automatic flattening of related objects in an object graph.  This feature was useful in the early days of Entity Framework, but less so now.  Removing this simplified the code and removed the dependency on Entity Framework.

David

First you can use SQL Server 2012's native backup to URL function.

Also you can use the Microsoft® SQL Server® Backup to Microsoft Windows® Azure®Tool, available here: https://www.microsoft.com/en-us/download/details.aspx?id=40740

But both those methods put your backups directly in Azure, which means that if you need your backups locally (and you do), you have to download them.  Another downside of this approach is that your backup time depends on your network bandwidth to Azure, so it's not really viable for backing up really large or a really large number of databases.

A better approach is to take your backups to some local disk and copy them to azure. 

A StorSimple https://www.storsimple.com/ is a really good option, as it dedupes and encrypts the data before backing it up to Azure, and handles the full lifecycle of the data.  Of course with StorSimple you need to install small storage appliance in your datacenter.

If you just want to copy from a local folder to Azure, that's really easy too using AzCopy, available here https://aka.ms/WaCopy .

So use a MaintenancePlan or scheduled job to backup your databases to a local disk or network file share, and then use AzCopy to copy them to Azure.  Your backups will be available locally until your Maintence Plan deletes them, and will be available in Azure forever.  Plus your backup time will not increase, even if it takes 18 hours to get all your nightly backups sent up to Azure.  Just run azcopy after your backups are done.  Like this

azcopy.exe backupfolder azure_container_url /destkey:yourkey /S /XO

so, something like

"c:\Program Files (x86)\Microsoft SDKs\Windows Azure\AzCopy\azcopy.exe" "C:\Program Files\Microsoft SQL Server\MSSQL11.MSSQLSERVER\MSSQL\Backup" "https://yourstorageaccount.blob.core.windows.net/yourcontainer" /destkey:AKSxxxxxxxxxxxxxxxxxxxxxxxxxxx /S /XO

You can also create a SQL Agent job to run this command.  If you do, remember to grant the SQL Agent Service rights to the backup folder.

You will also want to delete some of these backups from Azure at some point according to a long term retention plan.  For instance retain daily backups for a week, weekly backups for a month, monthly backups for a year, annual backups for 5 years, where the first backup of the week is the "weeky" backup, the first backup of the month is the "monthly" backtup etc.  But that's a subject for another day. . .

David