using System;

namespace SoftwarePatterns.Core.Proxy

public class Order

{

public int Id { get; set; }

public string Name { get; set; }

public DateTime OrderDate { get; set; }

public int[] OrderDetails { get; set; }

public int CustomerId { get; set; }

}

using System;

using System.Runtime.Caching;

namespace SoftwarePatterns.Core.Proxy

public class OrderCacheRepository : OrderRepository

{

public override Order GetById(int id)

{

var cacheKey = CreateCacheKey<Order>(id);

var entity = MemoryCache.Default[cacheKey] as Order;

if (entity == null)

{

entity = base.GetById(id);

var cacheItem = new CacheItem(cacheKey, entity);

var policy = new CacheItemPolicy();

MemoryCache.Default.Add(cacheItem, policy);

}

return entity;

}

private static string CreateCacheKey<T>(params object[] parms)

{

var paramKey = string.Join("-", parms.ToString());

if(string.IsNullOrEmpty(paramKey) || string.IsNullOrWhiteSpace(paramKey)) throw new ArgumentException("Parameter provided could not be used to generate cache key");

return string.Format("{0}-{1}", typeof (T).Name.ToLowerInvariant(), paramKey);

}

}

using System;

using System.Linq;

namespace SoftwarePatterns.Core.Proxy

public class OrderRepository : Repository<Order>

{

public override Order GetById(int id)

{

OrderFetched++;

Console.WriteLine("Going to database to get order");

return new Order

{

Id = id,

CustomerId = 1,

OrderDate = DateTime.Now,

OrderDetails = new[] {1, 2, 34}

};

}

public int OrderFetched { get; set; }

}

Define:

A proxy, in its most general form, is a class functioning as an interface to something else. The proxy could interface to anything: a network connection,

a large object in memory, a file, or some other resource that is expensive or impossible to duplicate.

Usage:

A remote proxy acts as a local representative of a remote object and abstracts away the details of the communication with the remote object.

A virtual proxy creates expensive objects on demand.

A protection proxy can be used to control access to the object, based on authorisation rules.

Examples:

We have already seen examples of the proxy object in the lazy loading pattern where objects or properties are loaded only when requested by the client

Consequences

Proxy objects must be kept up to date with the real object either manually or via code generation (this is common in ORM or remote proxy in WCF)

Client code may make incorrect assumptions about the behaviour of real objects

namespace SoftwarePatterns.Core.Proxy

public abstract class Repository<T>

{

public abstract T GetById(int id);

}

<Reference Include="System.Runtime.Caching" />

<Compile Include="Proxy\Order.cs" />

<Compile Include="Proxy\OrderCacheRepository.cs" />

<Compile Include="Proxy\OrderRepository.cs" />

<Compile Include="Proxy\Repository.cs" />

<Content Include="Proxy\ReadMe.txt" />

using SoftwarePatterns.Core.Proxy;

using Xunit;

namespace SoftwarePatterns.Tests.Proxy

public class OrderRepositoryTests

{

public class GetByIdMethod

{

[Fact]

public void ShouldOnlyFetchOnce()

{

var repository = new OrderCacheRepository();

var order1 = repository.GetById(1);

var order2 = repository.GetById(1);

var order3 = repository.GetById(1);

Assert.Equal(1, repository.OrderFetched);

}

}

}

<Compile Include="Proxy\OrderRepositoryTests.cs" />

using SoftwarePatterns.Core.Proxy;

//public static void Main()

//{

// //Simple classic pub sub model

// //var ticker = new SimpleStockTicker();

// //var google = new GoogleStockObserver(ticker);

// //var msft = new MicrosftStockObserver(ticker);

// //ticker.RunTicker();

// //Event and delegate based approach

// //var ticker = new EventStockTicker();

// //var google = new GoogleEventStockObserver(ticker);

// //var msft = new MicrosoftEventStockObserver(ticker);

// //ticker.RunTicker();

// //using IObserver<T>

// var ticker = new ObservableStockTicker();

// var google = new GoogleObserver();

// var msft = new MicrosoftObserver();

// using (ticker.Subscribe(google))

// using (ticker.Subscribe(msft))

// {

// ticker.RunTicker();

// }

// Console.ReadLine();

//}

#endregion

#region Proxy

public static void Main()

{

var order1 = new OrderCacheRepository().GetById(1);

var order2 = new OrderCacheRepository().GetById(1);

var order3 = new OrderCacheRepository().GetById(1);