Gut Instinct

Craigandrsquo;s Utility Library 3.0 Released

James Craig — Tue, 20 Dec 2011 21:37:44 GMT

OK, so I should have uploaded this last week but I’ve been a bit lazy (I’m on vacation). That being said, the big news is that Craig’s Utility Library has a new version. However, it’s not 2.3 (which would be the next version sequentially) but 3.0. The reason for the jump is that this version is not exactly compatible with the older version. Much of the code has been reworked completely (much of the static methods are now extension methods, etc). Here is just the short list that they would let me put up on CodePlex: Fixes Added fix for length of columns when dealing with nvarchars in SQLServer class. Added fix for Map objects that were set to cascade where ManyToMany and ManyToOne objects underneath were not cascading properly. Added Any and All functions to ObjectBaseClass that accept SQL Commands/CommandTypes. Fixed cascading saves for Mapped objects in ORM. Added check in StringID and StringReference for -1 (max length), so that the validation actually works on update... Added fix for ZipFile when calling AddFile (now creates the zip file correctly). Added check to ORM code to make sure that load commands aren't overwritten with defaults. Fixed issue with ObjectBaseClass if the instance returned by Any is null. Fixed bug in DataMapper when using the AutoMap feature. Fixed small bug in RGBHistogram's Equalize function as well as Equalize function in BitmapExtensions. Fixed issue that allows unsafe code to be tested/run (seems to be related to updating to 4.0). Fixed bug in Random class's NextColor function. Fixed issue with ArgsParser code involving double quotes and reduced code a bit. Fixed minor issues with RSAEncryption class. Fixed minor issues/made code simpler for Conversion, Matrix, Set, and Vector3 classes. Fixed a couple of bugs in vector class (initial size of items not set right, removing first item in list, etc.) Fixed various issues/improved BinaryTree class Changes Most static functions have been moved to various extension methods and a number of functions have been added (too many to list here). On top of that a number of changes have been made to various classes: Added ability in ProfilerManager to get data for a specific function and made ProfilerInfo public Changed the parameters of the Column DataClass (now has a generic default value, uses DbType instead of SqlDbType for the DataType property, etc) Added ability to query list of users who logged into a machine (WMI code) Added a ClearMappings function to MicroORM. Updated SQLHelper's code (removed functions that are no longer used, instead keeping generic versions). Merged AddParameter and AddOutputParameter into one function (and GetParameter and GetOutputParameter) and changed order of a couple parameters. Updated ErrorManager code to use extension methods moved from the Web namespace (DumpCache, DumpApplicationState, etc). Updated WebPageThumbnail code to use some default values to make things simpler. Made TypeMapping class a bit more fluent to make adding mappings easier. Simplified Validator code and added a number of functions for new validation rules. Finished adding IoC code (very simple IoC container). Rewrote LDAP code (simplified). Reworked some of the Reflection.Emit classes (mostly to reduce redundant functions, replace wordy code, etc.) Added GenericStringFormatter class (used by FormatString function in the StringExtensions class) Moved NaiveBayes class to AI namespace. Improved ListMapping functionality Added functions to priority queue for adding items, improved Pop functionality. Added DateSpan class. Moved Cisco classes to FileFormats namespace Also Items Have been removed due to the fact that they were either too difficult to maintain or simply not being used: Removed Youtube code (will eventually replace this with Google API namespace. Removed FOAF and APML helpers as neither format seem to be used... Removed Speech namespace (wasn't really maintaining it)... Removed Pair and Triple classes (not needed with addition of System.Tuple) This doesn’t include the new list of extension methods: Utilities.DataTypes.ExtensionMethods Array extensions Clear Combine DateTime extensions DaysInMonth DaysLeftInMonth DaysLeftInYear FirstDayOfMonth FirstDayOfWeek FromUnixTime (actually extension for int and long values) IsInFuture IsInPast IsWeekDay IsWeekEnd LastDayOfMonth LastDayOfWeek ToUnix Generic object extensions If NotIf Return Chain Do Execute ICollection extensions AddAndReturn AddRange AddIf AddIfUnique Remove RemoveRange IComparable extensions Between IDictionary extensions Sort SortByValue IEnumerable extensions Exists For ForEach ForParallel ForEachParallel IsNullOrEmpty RemoveDefaults ToArray ToString TrueForAll TryAll TryAllParallel MatchCollection extensions Where string extensions Encode FromBase64 Left Right ToBase64 ToByteArray ToFirstCharacterUpperCase ToSentenceCapitalize ToTitleCase NumberTimesOccurs Reverse FilterOutText KeepFilterText AlphaNumericOnly AlphaCharactersOnly NumericOnly IsUnicode FormatString RegexFormat Various type conversion/type checking extensions FormatToString IsNotDefault IsDefault IsNotNull IsNull IsNotNullOrDBNull IsNullOrDBNull NullCheck ThrowIfDefault ThrowIfNullOrEmpty ThrowIfNullOrDBNull ToSQLDbType ToDbType ToType TryTo Various value type extensions ToBool (int) ToInt (bool) ToBase64String (byte array) ToEncodedString (byte array) IsUnicode (byte array) Utilities.IO.ExtensionMethods Serialization extensions ToBinary ToJSON ToSOAP ToXML ToObject JSONToObject SOAPToObject XMLToObject Uri extensions Read ReadBinary Math extensions Betweek Clamp Factorial Max Median Min Mode Pow Round StandardDeviation Sqrt Variance Permute Utilities.SQL.ExtensionMethods DbCommand extensions AddParameter BeginTransaction ClearParameters Close Commit ExecuteDataSet ExecuteScalar GetOutputParameter Open Rollback DbDataReader extensions GetParameter Utilities.Compression.ExtensionMethods Compress (both byte arrays and strings) Decompress (both byte arrays and strings) Utilities.Encryption.ExtensionMethods Hash (Now handles all hash algorithms in one function for both byte arrays and strings) Encrypt (Handles any symmetric encryption algorithm inside .Net) Decrypt (Handles any symmetric encryption algorithm inside .Net) Utilities.IO.ExtensionMethods DirectoryInfo extensions CopyTo DeleteAll DeleteFiles DeleteFilesNewerThan DeleteFilesOlderThan Size SetAttribute FileInfo extensions Append CompareTo Read ReadBinary Save SaveAsync SetAttributes String extensions RemoveIllegalDirectoryNameCharacters RemoveIllegalFileNameCharacters Utilities.Web.ExtensionMethods Web related extensions AbsoluteRoot AddScriptFile ContainsHTML HTTPCompress IsEncodingAccepted RelativeRoot RemoveURLIllegalCharacters SetEncoding StripHTML IPAddress extensions GetHostName Minification Combine (can be used for HTML,JavaScript, or CSS) Minify (can be used for HTML, JavaScript, or CSS) HttpRequest extensions IsMobile Utilities.Image.ExtensionMethods All Bitmap functions were moved Added ToBase64 extension method Added DrawRoundedRectangle extension Screen extensions TakeScreenShot Utilities.Error.ExtensionMethods Various error related extensions DumpApplicationState DumpCache DumpCookies DumpRequestVariable DumpResponseVariable DumpServerVars DumpSession Utilities.Reflection.ExtensionMethods Various reflection related extensions CallMethod CreateInstance DumpProperties GetAttribute GetAttributes GetName GetObjects GetProperty GetPropertyGetter GetPropertyName GetPropertyType GetPropertySetter GetTypes IsIEnumerable IsOfType Load LoadAssemblies MarkedWith MakeShallowCopy SetProperty ToLongVersionString ToShortVersionString Utilities.Environment.ExtensionMethods Process related extensions KillProcessAsync GetInformation I know that’s a long list, but this isn’t everything that has been updated. On top of all of that, there is now a set of tests that is available with the code. And I’m working on getting a nightly build going. With the nightly build, I’m going to automatically publish to NuGet. So if you’re using NuGet to get it, you’re going to be getting the nightly build. Anyway, that’s it for this post. So download the code, leave comments, and happy coding.

Building an DI Container

James Craig — Sun, 13 Nov 2011 16:51:57 GMT

It has been a while since I’ve written anything. To say the least things are hectic. Most of which, I can’t really talk about at this point (let’s just say that I’m working on a product for a sector of the business world. I think I can say that much, but not much more until it gets closer to release). Anyway, today I’m finally getting around to talking about one more item that I’ve added to my utility library. Specifically I’ve added a basic DI container (dependency injection). Note that this next section is an over simplification and I’m tired so if it’s wrong, feel free to say so. Anyway, Dependency injection is a specific form of inversion of control. Inversion of control is when you invert the flow of a system. Instead of one central bit of code deciding how everything is run, it’s up to the individual pieces to know how to do the actual work. For instance, if I call an object factory to create a database connection for me, I don’t care how it’s created or how the connection is doing anything as long as it gets done. And dependency injection is just a specific form of IoC. Instead of hard coding our dependencies in each individual class, we allow someone to pass in the component that they want to use. You can actually do this manually (using a factory pattern, etc.) and still have a form of dependency injection. However you can also automate this process using one of the many dependency injectors out there (I personally like Ninject and based the code below on it). But where’s the fun in using someone else’s when all we have to do is spend an afternoon and build our own. 1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Providers;

28: using Utilities.IoC.Mappings;

29: using Utilities.IoC.Mappings.Interfaces;

30: using System.Reflection;

31: using System.IO;

32: using Utilities.IO.ExtensionMethods;

33: using Utilities.Reflection.ExtensionMethods;

34: using Utilities.DataTypes.ExtensionMethods;

35: #endregion

36:

37: namespace Utilities.IoC

38: {

39: /// andlt;summaryandgt;

40: /// Manager class

41: /// andlt;/summaryandgt;

42: public class Manager

43: {

44: #region Constructor

45:

46: /// andlt;summaryandgt;

47: /// Constructor

48: /// andlt;/summaryandgt;

49: public Manager()

50: {

51: if (ProviderManager.IsNull())

52: ProviderManager = new ProviderManager();

53: if (MappingManager.IsNull())

54: MappingManager = new MappingManager(ProviderManager);

55: }

56:

57: #endregion

58:

59: #region Functions

60:

61: /// andlt;summaryandgt;

62: /// Loads all mapping modules found within the assembly

63: /// andlt;/summaryandgt;

64: /// andlt;param name=andquot;ModuleAssemblyandquot;andgt;Module assemblyandlt;/paramandgt;

65: public void Setup(Assembly ModuleAssembly)

66: {

67: ProviderManager.Setup(ModuleAssembly);

68: MappingManager.Setup(ModuleAssembly);

69: }

70:

71: /// andlt;summaryandgt;

72: /// Loads all mapping modules found within the assemblies

73: /// andlt;/summaryandgt;

74: /// andlt;param name=andquot;ModuleAssembliesandquot;andgt;Module assembliesandlt;/paramandgt;

75: public void Setup(IEnumerableandlt;Assemblyandgt; ModuleAssemblies)

76: {

77: ModuleAssemblies.ForEach(x =andgt; Setup(x));

78: }

79:

80: /// andlt;summaryandgt;

81: /// Loads all mapping modules found within a specific directory

82: /// andlt;/summaryandgt;

83: /// andlt;param name=andquot;Directoryandquot;andgt;Directory to scan for modulesandlt;/paramandgt;

84: /// andlt;param name=andquot;RecursiveScanandquot;andgt;Determines if sub directories should be scannedandlt;/paramandgt;

85: public void Setup(string Directory, bool ScanSubDirectories = true)

86: {

87: Setup(new DirectoryInfo(Directory).LoadAssemblies(ScanSubDirectories));

88: }

89:

90: /// andlt;summaryandgt;

91: /// Creates an object of the specified type

92: /// andlt;/summaryandgt;

93: /// andlt;typeparam name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/typeparamandgt;

94: /// andlt;returnsandgt;An object of the specified typeandlt;/returnsandgt;

95: public ServiceType Getandlt;ServiceTypeandgt;()

96: {

97: return (ServiceType)Get(typeof(ServiceType));

98: }

99:

100: /// andlt;summaryandgt;

101: /// Creates an object of the specified type associated with the attribute type

102: /// andlt;/summaryandgt;

103: /// andlt;typeparam name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/typeparamandgt;

104: /// andlt;typeparam name=andquot;AttributeTypeandquot;andgt;Attribute typeandlt;/typeparamandgt;

105: /// andlt;returnsandgt;An object of the specified typeandlt;/returnsandgt;

106: public ServiceType Getandlt;ServiceType, AttributeTypeandgt;()

107: {

108: return (ServiceType)Get(typeof(ServiceType), typeof(AttributeType));

109: }

110:

111: /// andlt;summaryandgt;

112: /// Creates an object of the specified type

113: /// andlt;/summaryandgt;

114: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

115: /// andlt;returnsandgt;An object of the specified typeandlt;/returnsandgt;

116: public object Get(Type ServiceType)

117: {

118: IMapping Mapping = MappingManager.GetMapping(ServiceType);

119: if (Mapping.IsNull())

120: throw new ArgumentException(andquot;ServiceType not found in mappingsandquot;);

121: return Mapping.Implementation.Create();

122: }

123:

124: /// andlt;summaryandgt;

125: /// Creates an object of the specified type associated with the attribute type

126: /// andlt;/summaryandgt;

127: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

128: /// andlt;param name=andquot;AttributeTypeandquot;andgt;Attribute typeandlt;/paramandgt;

129: /// andlt;returnsandgt;An object of the specified typeandlt;/returnsandgt;

130: public object Get(Type ServiceType, Type AttributeType)

131: {

132: IMapping Mapping = MappingManager.GetMapping(ServiceType, AttributeType);

133: if (Mapping.IsNull())

134: throw new ArgumentException(andquot;ServiceType not found in mappingsandquot;);

135: return Mapping.Implementation.Create();

136: }

137:

138: #endregion

139:

140: #region Properties

141:

142: protected static ProviderManager ProviderManager { get; set; }

143: protected static MappingManager MappingManager { get; set; }

144:

145: #endregion

146: }

147: }

This is our main point of code that we are going to use to get our objects. We set it up, call Get, and it will return to us our object (with the appropriate items injected). One thing that you’ll notice is that there are a couple nonstandard C# calls in there (specifically the ForEach on the IEnumerable, IsNull, etc). These are all functions from the new utility library that I’m working on. I’ve been adding quite a bit to it, tons of extension methods, etc. So go and check out the repository as all of my code on here uses it (or at least the code on here uses a version of it). Plus any updates to the code can be found there also as I tend to forget the pages on this site. Anyway another thing you may notice is there isn’t much code here. Most of the actual work is going to be done in the ProviderManager and MappingManager.

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Providers.Interfaces;

28: using Utilities.IoC.Providers.Scope;

29: using Utilities.Reflection;

30: using Utilities.Reflection.ExtensionMethods;

31: using Utilities.DataTypes.ExtensionMethods;

32: using System.Reflection;

33: #endregion

34:

35: namespace Utilities.IoC.Providers

36: {

37: /// andlt;summaryandgt;

38: /// Provider manager

39: /// andlt;/summaryandgt;

40: public class ProviderManager

41: {

42: #region Constructor

43:

44: /// andlt;summaryandgt;

45: /// Constructor

46: /// andlt;/summaryandgt;

47: public ProviderManager()

48: {

49: Providers = new Listandlt;IProviderandgt;();

50: Providers.AddRange(typeof(ProviderManager).Assembly.GetObjectsandlt;IProviderandgt;());

51: }

52:

53: #endregion

54:

55: #region Functions

56:

57: /// andlt;summaryandgt;

58: /// Sets up all providers found within the assembly specified

59: /// andlt;/summaryandgt;

60: /// andlt;param name=andquot;Assemblyandquot;andgt;Assembly to scanandlt;/paramandgt;

61: public void Setup(Assembly Assembly)

62: {

63: Providers.AddRange(Assembly.GetObjectsandlt;IProviderandgt;());

64: }

65:

66: /// andlt;summaryandgt;

67: /// Gets the specified provider based on the scope specified

68: /// andlt;/summaryandgt;

69: /// andlt;param name=andquot;Scopeandquot;andgt;Scopeandlt;/paramandgt;

70: /// andlt;returnsandgt;The specified providerandlt;/returnsandgt;

71: public IProvider GetProvider(BaseScope Scope)

72: {

73: return Providers.FirstOrDefault(x =andgt; x.ProviderScope.Equals(Scope));

74: }

75:

76: #endregion

77:

78: #region Properties

79:

80: protected virtual Listandlt;IProviderandgt; Providers { get; set; }

81:

82: #endregion

83: }

84: }

The ProviderManager above holds a list of providers. These providers determine how to handle an implementation when you provide the system with one. The implementations actually determine how something is created. For instance, the code base only has one provider at present called Standard.

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Providers.Scope;

28: using Utilities.IoC.Providers.Interfaces;

29: using Utilities.IoC.Mappings;

30: using Utilities.IoC.Providers.Implementations;

31: #endregion

32:

33: namespace Utilities.IoC.Providers.DefaultProviders

34: {

35: /// andlt;summaryandgt;

36: /// Standard provider

37: /// andlt;/summaryandgt;

38: public class Standard : IProvider

39: {

40: public IImplementation CreateImplementation(Type ImplementationType, MappingManager MappingManager)

41: {

42: return new Implementations.Standard(ImplementationType, MappingManager);

43: }

44:

45:

46: public BaseScope ProviderScope

47: {

48: get { return new StandardScope(); }

49: }

50:

51: public IImplementation CreateImplementation(IImplementation Implementation, MappingManager MappingManager)

52: {

53: return CreateImplementation(Implementation.ReturnType, MappingManager);

54: }

55:

56: public IImplementation CreateImplementationandlt;ImplementationTypeandgt;(Funcandlt;ImplementationTypeandgt; Implementation)

57: {

58: return new Delegateandlt;ImplementationTypeandgt;(Implementation);

59: }

60: }

61: }

This provider just creates a new implementation object (either a Delegate or Standard implementation depending) each time it’s fed anything. However we could have a provider called Singleton or something and have it return its own implementation types. We determine which provider to use in the ProviderManager based on something called Scopes:

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: #endregion

28:

29: namespace Utilities.IoC.Providers.Scope

30: {

31: /// andlt;summaryandgt;

32: /// Standard scope

33: /// andlt;/summaryandgt;

34: public class StandardScope : BaseScope

35: {

36: #region Constructor

37:

38: public StandardScope()

39: : base()

40: {

41: }

42:

43: #endregion

44:

45: #region Properties

46:

47: public override string Name { get { return andquot;Standardandquot;; } }

48:

49: #endregion

50: }

51: }

As you can see, it’s just a holder of info. So for our Singleton provider example, we would need to create a Singleton scope and have it return that value so we know which to use. Anyway, the next bit is the actual implementations:

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Mappings;

28: using Utilities.IoC.Mappings.Interfaces;

29: using System.Reflection;

30: using Utilities.IoC.Mappings.Attributes;

31: using Utilities.IoC.Providers.BaseClasses;

32: using Utilities.DataTypes.ExtensionMethods;

33: using Utilities.Reflection.ExtensionMethods;

34: #endregion

35:

36: namespace Utilities.IoC.Providers.Implementations

37: {

38: /// andlt;summaryandgt;

39: /// Standard implementation class

40: /// andlt;/summaryandgt;

41: public class Standard : BaseImplementation

42: {

43: #region Constructor

44:

45: /// andlt;summaryandgt;

46: /// Constructor

47: /// andlt;/summaryandgt;

48: /// andlt;param name=andquot;ImplementationTypeandquot;andgt;Implementation typeandlt;/paramandgt;

49: /// andlt;param name=andquot;MappingManagerandquot;andgt;Mapping managerandlt;/paramandgt;

50: public Standard(Type ImplementationType, MappingManager MappingManager)

51: {

52: this.ReturnType = ImplementationType;

53: this.MappingManager = MappingManager;

54: }

55:

56: #endregion

57:

58: #region Functions

59:

60: #region Create

61:

62: public override object Create()

63: {

64: ConstructorInfo Constructor = Utils.ConstructorList.ChooseConstructor(ReturnType, MappingManager);

65: object Instance = CreateInstance(Constructor);

66: SetupProperties(Instance);

67: SetupMethods(Instance);

68: return Instance;

69: }

70:

71: #endregion

72:

73: #region SetupMethods

74:

75: private void SetupMethods(object Instance)

76: {

77: if (Instance.IsNull())

78: return;

79: foreach (MethodInfo Method in Instance.GetType().GetMethods().Where(x =andgt; IsInjectable(x)))

80: Method.Invoke(Instance, Method.GetParameters().ForEach(x =andgt; CreateInstance(x)).ToArray());

81: }

82:

83: #endregion

84:

85: #region SetupProperties

86:

87: private void SetupProperties(object Instance)

88: {

89: if (Instance.IsNull())

90: return;

91: Instance.GetType()

92: .GetProperties()

93: .Where(x =andgt; IsInjectable(x))

94: .ForEachandlt;PropertyInfoandgt;(x =andgt; Instance.SetProperty(x, CreateInstance(x)));

95: }

96:

97: #endregion

98:

99: #region IsInjectable

100:

101: private bool IsInjectable(MethodInfo Method)

102: {

103: return IsInjectable(Method.GetCustomAttributes(false));

104: }

105:

106: private bool IsInjectable(PropertyInfo Property)

107: {

108: return IsInjectable(Property.GetCustomAttributes(false));

109: }

110:

111: private bool IsInjectable(object[] Attributes)

112: {

113: return Attributes.OfTypeandlt;Injectandgt;().Count() andgt; 0;

114: }

115:

116: #endregion

117:

118: #region CreateInstance

119:

120: private object CreateInstance(ConstructorInfo Constructor)

121: {

122: if (Constructor.IsNull() || MappingManager.IsNull())

123: return null;

124: Listandlt;objectandgt; ParameterValues = new Listandlt;objectandgt;();

125: Constructor.GetParameters().ForEachandlt;ParameterInfoandgt;(x =andgt; ParameterValues.Add(CreateInstance(x)));

126: return Constructor.Invoke(ParameterValues.ToArray());

127: }

128:

129: private object CreateInstance(ParameterInfo Parameter)

130: {

131: return CreateInstance(Parameter.GetCustomAttributes(false), Parameter.ParameterType);

132: }

133:

134: private object CreateInstance(PropertyInfo Property)

135: {

136: return CreateInstance(Property.GetCustomAttributes(false), Property.PropertyType);

137: }

138:

139: private object CreateInstance(object[] Attributes, Type Type)

140: {

141: if (Attributes.Length andgt; 0)

142: {

143: foreach (Attribute Attribute in Attributes)

144: {

145: object TempObject = GetObject(Type, Attribute.GetType());

146: if (!TempObject.IsNull())

147: return TempObject;

148: }

149: }

150: return GetObject(Type);

151: }

152:

153: #endregion

154:

155: #region GetObject

156:

157: private object GetObject(Type Type)

158: {

159: IMapping Mapping = MappingManager.GetMapping(Type);

160: return Mapping.IsNull() ? null : Mapping.Implementation.Create();

161: }

162:

163: private object GetObject(Type Type, Type AttributeType)

164: {

165: IMapping Mapping = MappingManager.GetMapping(Type, AttributeType);

166: return Mapping.IsNull() ? null : Mapping.Implementation.Create();

167: }

168:

169: #endregion

170:

171: #endregion

172:

173: #region Properties

174:

175: /// andlt;summaryandgt;

176: /// Mapping manager

177: /// andlt;/summaryandgt;

178: protected virtual MappingManager MappingManager { get; set; }

179:

180: #endregion

181: }

182: }

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Providers.BaseClasses;

28: #endregion

29:

30: namespace Utilities.IoC.Providers.Implementations

31: {

32: /// andlt;summaryandgt;

33: /// Delegate implementation

34: /// andlt;/summaryandgt;

35: /// andlt;typeparam name=andquot;Tandquot;andgt;Return type of the delegateandlt;/typeparamandgt;

36: public class Delegateandlt;Tandgt; : BaseImplementation

37: {

38: #region Constructor

39:

40: /// andlt;summaryandgt;

41: /// Constructor

42: /// andlt;/summaryandgt;

43: /// andlt;param name=andquot;Implementationandquot;andgt;Implementation delegateandlt;/paramandgt;

44: public Delegate(Funcandlt;Tandgt; Implementation)

45: {

46: this.Implementation = Implementation;

47: ReturnType = typeof(T);

48: }

49:

50: #endregion

51:

52: #region Functions

53:

54: /// andlt;summaryandgt;

55: /// Creates an object based on a delegate

56: /// andlt;/summaryandgt;

57: /// andlt;returnsandgt;An objectandlt;/returnsandgt;

58: public override object Create()

59: {

60: return Implementation();

61: }

62:

63: #endregion

64:

65: #region Properties

66:

67: /// andlt;summaryandgt;

68: /// Delegate used to create objects

69: /// andlt;/summaryandgt;

70: protected virtual Funcandlt;Tandgt; Implementation { get; set; }

71:

72: #endregion

73: }

74: }

You’ll notice that the Delegate implementation is a bit simpler. In this case you provide a Func and we just assume you know how you want an item created so we just return it. The standard implementation though is a bit more complicated.

When we call the standard implementation’s Create function, it calls this little utility to determine which constructor to use:

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using System.Reflection;

28: using Utilities.IoC.Mappings;

29: #endregion

30:

31: namespace Utilities.IoC.Utils

32: {

33: public static class ConstructorList

34: {

35: public static ConstructorInfo ChooseConstructor(Type ImplementationType, MappingManager MappingManager)

36: {

37: ConstructorInfo[] Constructors = ImplementationType.GetConstructors();

38: int MaxValue = int.MinValue;

39: ConstructorInfo CurrentConstructor = null;

40: foreach (ConstructorInfo Constructor in Constructors)

41: {

42: int Count = GetParameterCount(Constructor, MappingManager);

43: if (Count andgt; MaxValue)

44: {

45: CurrentConstructor = Constructor;

46: MaxValue = Count;

47: }

48: }

49: return CurrentConstructor;

50: }

51:

52: private static int GetParameterCount(ConstructorInfo Constructor, MappingManager MappingManager)

53: {

54: int Count = 0;

55: ParameterInfo[] Parameters = Constructor.GetParameters();

56: foreach (ParameterInfo Parameter in Parameters)

57: {

58: bool Inject = true;

59: object[] Attributes = Parameter.GetCustomAttributes(false);

60: if (Attributes.Length andgt; 0)

61: {

62: foreach (Attribute Attribute in Attributes)

63: {

64: if (MappingManager.GetMapping(Parameter.ParameterType, Attribute.GetType()) != null)

65: {

66: ++Count;

67: Inject = false;

68: break;

69: }

70: }

71: }

72: if (Inject)

73: {

74: if (MappingManager.GetMapping(Parameter.ParameterType) != null)

75: ++Count;

76: }

77: }

78: if (Count == Parameters.Length)

79: return Count;

80: return int.MinValue;

81: }

82: }

83: }

This bit of code simply determines which constructor has the most items that we know how to create and returns it. The Standard.Create function then takes that constructor and calls CreateInstance. This call determines the parameters of the constructor, and creates each one in turn using the MappingManager (we’ll get to that later). It then feeds the newly created items into the constructor and creates the object. After that it searches each method and each property to determine if they have been marked for injection also (note that this is done using an attribute called Inject). If it finds anything, it creates more objects in the same manner as the parameters for the constructor. Once it’s done with that, it returns the newly created object.

So at this point we have our code to actually create our objects but we have nothing mapping it to anything. We can create but we don’t know when and we don’t know why. That’s where the MappingManager comes in.

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Mappings.Interfaces;

28: using System.Reflection;

29: using Utilities.IoC.Providers;

30: using Utilities.Reflection.ExtensionMethods;

31: using Utilities.IoC.Mappings.Internal_Classes;

32: using Utilities.IoC.Mappings.BaseClasses;

33: #endregion

34:

35: namespace Utilities.IoC.Mappings

36: {

37: /// andlt;summaryandgt;

38: /// Mapping manager

39: /// andlt;/summaryandgt;

40: public class MappingManager

41: {

42: #region Constructor

43:

44: /// andlt;summaryandgt;

45: /// Constructor

46: /// andlt;/summaryandgt;

47: public MappingManager(ProviderManager ProviderManager)

48: {

49: Modules = new Listandlt;IModuleandgt;();

50: Mappings = new Listandlt;IMappingandgt;();

51: this.ProviderManager = ProviderManager;

52: }

53:

54: #endregion

55:

56: #region Functions

57:

58: /// andlt;summaryandgt;

59: /// Scans the assembly for mapping modules and creates them

60: /// andlt;/summaryandgt;

61: /// andlt;param name=andquot;ModuleAssemblyandquot;andgt;andlt;/paramandgt;

62: public void Setup(Assembly ModuleAssembly)

63: {

64: IEnumerableandlt;Typeandgt; Modules = ModuleAssembly.GetTypes(typeof(IModule));

65: Listandlt;IModuleandgt; TempModules = new Listandlt;IModuleandgt;();

66: foreach (Type Module in Modules)

67: {

68: if (!Module.IsInterface andamp;andamp; !Module.IsAbstract)

69: TempModules.Add((IModule)Module.Assembly.CreateInstance(Module.FullName));

70: }

71: foreach (IModule Module in TempModules)

72: {

73: Module.Manager = this;

74: Module.Setup();

75: }

76: this.Modules.AddRange(TempModules);

77: }

78:

79: /// andlt;summaryandgt;

80: /// Creates a mapping object

81: /// andlt;/summaryandgt;

82: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

83: /// andlt;returnsandgt;a mapping objectandlt;/returnsandgt;

84: public IMapping CreateMapping(Type ServiceType)

85: {

86: IMapping Mapping = new Mapping(ServiceType, ProviderManager, this);

87: Mappings.Add(Mapping);

88: return Mapping;

89: }

90:

91: /// andlt;summaryandgt;

92: /// Creates a mapping object

93: /// andlt;/summaryandgt;

94: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

95: /// andlt;param name=andquot;AttributeTypeandquot;andgt;Attribute typeandlt;/paramandgt;

96: /// andlt;returnsandgt;A mapping objectandlt;/returnsandgt;

97: public IMapping CreateMapping(Type ServiceType, Type AttributeType)

98: {

99: IMapping Mapping = new Mapping(ServiceType, AttributeType, ProviderManager, this);

100: Mappings.Add(Mapping);

101: return Mapping;

102: }

103:

104: /// andlt;summaryandgt;

105: /// Gets the mapping that matches this service type

106: /// andlt;/summaryandgt;

107: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

108: /// andlt;returnsandgt;The mapping associated with this service typeandlt;/returnsandgt;

109: public IMapping GetMapping(Type ServiceType)

110: {

111: MappingKey Key = new MappingKey(ServiceType, null, ProviderManager, this);

112: return Mappings.Find(x =andgt; x.Equals(Key));

113: }

114:

115: /// andlt;summaryandgt;

116: /// Gets the mapping that matches this service type and attribute type

117: /// andlt;/summaryandgt;

118: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

119: /// andlt;param name=andquot;AttributeTypeandquot;andgt;Attribute typeandlt;/paramandgt;

120: /// andlt;returnsandgt;The mapping associated with this service type and attribute typeandlt;/returnsandgt;

121: public IMapping GetMapping(Type ServiceType, Type AttributeType)

122: {

123: MappingKey Key = new MappingKey(ServiceType, AttributeType, ProviderManager, this);

124: return Mappings.Find(x =andgt; x.Equals(Key));

125: }

126:

127: #endregion

128:

129: #region Properties

130:

131: /// andlt;summaryandgt;

132: /// Modules listing

133: /// andlt;/summaryandgt;

134: protected virtual Listandlt;IModuleandgt; Modules { get; set; }

135:

136: /// andlt;summaryandgt;

137: /// Mapping listing

138: /// andlt;/summaryandgt;

139: protected virtual Listandlt;IMappingandgt; Mappings { get; set; }

140:

141: /// andlt;summaryandgt;

142: /// Provider manager

143: /// andlt;/summaryandgt;

144: protected virtual ProviderManager ProviderManager { get; set; }

145:

146: #endregion

147: }

148: }

The MappingManager is also a bit bare on implementation. All it does is holds a series of mappings and modules and creates them/returns them as necessary. A module is actually not defined inside the system itself. It’s what the end user would use to let the system know what mappings to use. It uses the following interface and base class:

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: #endregion

28:

29: namespace Utilities.IoC.Mappings.Interfaces

30: {

31: /// andlt;summaryandgt;

32: /// Mapping module interface

33: /// andlt;/summaryandgt;

34: public interface IModule

35: {

36: #region Functions

37:

38: /// andlt;summaryandgt;

39: /// Called to setup the module (actual mapping occurs here)

40: /// andlt;/summaryandgt;

41: void Setup();

42:

43: #endregion

44:

45: #region Properties

46:

47: MappingManager Manager { get; set; }

48:

49: #endregion

50: }

51: }

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Mappings.Interfaces;

28: #endregion

29:

30: namespace Utilities.IoC.Mappings.BaseClasses

31: {

32: /// andlt;summaryandgt;

33: /// Base module class

34: /// andlt;/summaryandgt;

35: public abstract class BaseModule : IModule

36: {

37: #region Functions

38:

39: public abstract void Setup();

40:

41: /// andlt;summaryandgt;

42: /// Creates a mapping using a specific service type

43: /// andlt;/summaryandgt;

44: /// andlt;typeparam name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/typeparamandgt;

45: /// andlt;returnsandgt;A mapping objectandlt;/returnsandgt;

46: public virtual IMapping Mapandlt;ServiceTypeandgt;()

47: {

48: return Map(typeof(ServiceType));

49: }

50:

51: /// andlt;summaryandgt;

52: /// Creates a mapping using a specific service type and attribute type

53: /// andlt;/summaryandgt;

54: /// andlt;typeparam name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/typeparamandgt;

55: /// andlt;typeparam name=andquot;AttributeTypeandquot;andgt;Attribute typeandlt;/typeparamandgt;

56: /// andlt;returnsandgt;A mapping objectandlt;/returnsandgt;

57: public virtual IMapping Mapandlt;ServiceType, AttributeTypeandgt;()

58: {

59: return Map(typeof(ServiceType), typeof(AttributeType));

60: }

61:

62: /// andlt;summaryandgt;

63: /// Creates a mapping using a specific service type

64: /// andlt;/summaryandgt;

65: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

66: /// andlt;param name=andquot;AttributeTypeandquot;andgt;Attribute typeandlt;/paramandgt;

67: /// andlt;returnsandgt;A mapping objectandlt;/returnsandgt;

68: public virtual IMapping Map(Type ServiceType, Type AttributeType = null)

69: {

70: return Manager.CreateMapping(ServiceType, AttributeType);

71: }

72:

73: #endregion

74:

75: #region Properties

76:

77: public virtual MappingManager Manager { get; set; }

78:

79: #endregion

80: }

81: }

For example, in your code, you would define a module like this:

1: public class Module : BaseModule

2: {

3: public override void Setup()

4: {

5: Mapandlt;ITestInterfaceandgt;().Toandlt;TestClass1andgt;().SetScope(new StandardScope());

6: Mapandlt;TestClass1andgt;().Toandlt;TestClass1andgt;(() =andgt; new TestClass1());

7: Mapandlt;ITestInterface, MyAttributeandgt;().To(new TestImplementation());

8: Mapandlt;TestClass2andgt;().Toandlt;TestClass2andgt;();

9: }

10: }

This module defines four mappings that the system can use. A mapping is, as the name suggests, a mapping between a key type and what should be created when it encounters that type. For instance whenever I hit the interface ITestInterface, we return a TestClass1 object. The module can also define the scope for the object and sets the implementation used. In the example above the first item maps ITestInterface to TestClass1 and sets the scope to StandardScope. The third item maps ITestInterface items that have the MyAttribute attribute to the TestImplementation implementation. Whenever you call Map in a module, it creates and returns a Mapping class:

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Mappings.BaseClasses;

28: using Utilities.IoC.Providers;

29: #endregion

30:

31: namespace Utilities.IoC.Mappings.Internal_Classes

32: {

33: /// andlt;summaryandgt;

34: /// Mapping class

35: /// andlt;/summaryandgt;

36: public class Mapping : MappingKey

37: {

38: #region Constructors

39:

40: /// andlt;summaryandgt;

41: /// Constructor

42: /// andlt;/summaryandgt;

43: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

44: public Mapping(Type ServiceType, ProviderManager ProviderManager, MappingManager MappingManager)

45: : base(ServiceType, null, ProviderManager, MappingManager)

46: {

47: }

48:

49: /// andlt;summaryandgt;

50: /// Constructor

51: /// andlt;/summaryandgt;

52: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

53: /// andlt;param name=andquot;AttributeTypeandquot;andgt;Attribute typeandlt;/paramandgt;

54: public Mapping(Type ServiceType, Type AttributeType, ProviderManager ProviderManager, MappingManager MappingManager)

55: : base(ServiceType, AttributeType, ProviderManager, MappingManager)

56: {

57: }

58:

59: #endregion

60: }

61: }

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Mappings.Interfaces;

28: using Utilities.IoC.Providers;

29: #endregion

30:

31: namespace Utilities.IoC.Mappings.BaseClasses

32: {

33: /// andlt;summaryandgt;

34: /// Mapping key

35: /// andlt;/summaryandgt;

36: public class MappingKey : BaseMapping

37: {

38: #region Constructor

39:

40: public MappingKey(Type ServiceType, Type AttributeType, ProviderManager ProviderManager, MappingManager MappingManager)

41: : base(ServiceType, AttributeType, ProviderManager, MappingManager)

42: {

43: }

44:

45: #endregion

46:

47: #region Functions

48:

49: public override bool Equals(object obj)

50: {

51: if (!(obj is IMapping))

52: return false;

53: IMapping ObjectMapping = (IMapping)obj;

54: return ObjectMapping.AttributeType == AttributeType

55: andamp;andamp; ObjectMapping.ServiceType == ServiceType;

56: }

57:

58: public override int GetHashCode()

59: {

60: int AttributeHash = AttributeType == null ? 1 : AttributeType.GetHashCode();

61: int ServiceHash = ServiceType == null ? 1 : ServiceType.GetHashCode();

62: return ServiceHash * AttributeHash;

63: }

64:

65: #endregion

66: }

67: }

1: /*

2: Copyright (c) 2011 andlt;a href=andquot;http://www.gutgames.comandquot;andgt;James Craigandlt;/aandgt;

3:

4: Permission is hereby granted, free of charge, to any person obtaining a copy

5: of this software and associated documentation files (the andquot;Softwareandquot;), to deal

6: in the Software without restriction, including without limitation the rights

7: to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

8: copies of the Software, and to permit persons to whom the Software is

9: furnished to do so, subject to the following conditions:

10:

11: The above copyright notice and this permission notice shall be included in

12: all copies or substantial portions of the Software.

13:

14: THE SOFTWARE IS PROVIDED andquot;AS ISandquot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

15: IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

16: FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

17: AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

18: LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

19: OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

20: THE SOFTWARE.*/

21:

22: #region Usings

23: using System;

24: using System.Collections.Generic;

25: using System.Linq;

26: using System.Text;

27: using Utilities.IoC.Mappings.Interfaces;

28: using Utilities.IoC.Providers;

29: using Utilities.IoC.Providers.Scope;

30: using Utilities.IoC.Providers.Interfaces;

31: #endregion

32:

33: namespace Utilities.IoC.Mappings.BaseClasses

34: {

35: /// andlt;summaryandgt;

36: /// Base mapping

37: /// andlt;/summaryandgt;

38: public class BaseMapping : IMapping

39: {

40: #region Constructor

41:

42: /// andlt;summaryandgt;

43: /// Constructor

44: /// andlt;/summaryandgt;

45: /// andlt;param name=andquot;ServiceTypeandquot;andgt;Service typeandlt;/paramandgt;

46: /// andlt;param name=andquot;AttributeTypeandquot;andgt;Attribute typeandlt;/paramandgt;

47: public BaseMapping(Type ServiceType, Type AttributeType, ProviderManager ProviderManager, MappingManager MappingManager)

48: {

49: this.ServiceType = ServiceType;

50: this.AttributeType = AttributeType;

51: this.ProviderManager = ProviderManager;

52: this.MappingManager = MappingManager;

53: this.Scope = new StandardScope();

54: }

55:

56: #endregion

57:

58: #region Functions

59:

60: public virtual IMapping Toandlt;ImplementationTypeandgt;()

61: {

62: return To(typeof(ImplementationType));

63: }

64:

65: public virtual IMapping To(Type ImplementationType)

66: {

67: Implementation = ProviderManager.GetProvider(Scope).CreateImplementation(ImplementationType, MappingManager);

68: return this;

69: }

70:

71: public virtual IMapping Toandlt;ImplementationTypeandgt;(Funcandlt;ImplementationTypeandgt; Implementation)

72: {

73: this.Implementation = ProviderManager.GetProvider(Scope).CreateImplementation(Implementation);

74: return this;

75: }

76:

77: public virtual IMapping To(Providers.Interfaces.IImplementation Implementation)

78: {

79: this.Implementation = Implementation;

80: return this;

81: }

82:

83: public virtual IMapping SetScope(BaseScope Scope)

84: {

85: this.Scope = Scope;

86: Implementation = ProviderManager.GetProvider(Scope).CreateImplementation(Implementation, MappingManager);

87: return this;

88: }

89:

90: #endregion

91:

92: #region Properties

93:

94: public virtual Type ServiceType { get; protected set; }

95: public virtual Type AttributeType { get; protected set; }

96: public virtual BaseScope Scope { get; protected set; }

97: public virtual IImplementation Implementation { get; protected set; }

98: protected virtual ProviderManager ProviderManager { get; set; }

99: protected virtual MappingManager MappingManager { get; set; }

100:

101: #endregion

102: }

103: }

The Mapping class is rather empty, the MappingKey actually defines the functions needed to determine which mapping is which. And the BaseMapping class holds the functions that set the scope, set the implementation, etc. And with that we’re done.

We create our modules, which sets our mappings, which the system holds for us until we tell the manager to get us a specific object type. Once we do that, it assembles our object for us. It’s not that complicated really and not that much code either (the largest file tops out at 189 lines of code including comments). And with that we have ourselves a simple DI container.

If you want updates, or find bugs, etc. check out the repository for the utility library (this is currently under the Utilities.IoC namespace). I’m terrible about updating my site but I update the code there whenever a bug is found. And hopefully I’ll finish my huge update to that library before too long (and it is going to contain a number of changes and additions). Anyway, take a look at the code and happy coding.

Utility Library Progress

James Craig — Thu, 08 Sep 2011 21:38:08 GMT

Between losing power for a week, being without internet for another week, and having family in town for yet another week, I’ve had no chance to post this. Nor have I had a chance to post a number of things that I’ve been meaning to. Hopefully that will change here. So if you've been following my utility library's progress, you'll know that I'm doing a major rework of a number of classes, I've been going in and rewriting my private unit tests so I can actually release them to everyone, and I've been clearing out old code that I no longer use or plan to maintain. This means that if you plan on going from the current 2.2 to what will become 3.0, you'll need to make some changes to your code. For example, let's look at some encryption code. Before if you wanted to encrypt something you would have to call the static function Utilities.Encryption.AESEncryption.Encrypt. It only took in a string and would only encrypt it using AES: 1: /// andlt;summaryandgt;

2: /// Encrypts a string

3: /// andlt;/summaryandgt;

4: /// andlt;param name=andquot;PlainTextandquot;andgt;Text to be encryptedandlt;/paramandgt;

5: /// andlt;param name=andquot;Passwordandquot;andgt;Password to encrypt withandlt;/paramandgt;

6: /// andlt;param name=andquot;Saltandquot;andgt;Salt to encrypt withandlt;/paramandgt;

7: /// andlt;param name=andquot;HashAlgorithmandquot;andgt;Can be either SHA1 or MD5andlt;/paramandgt;

8: /// andlt;param name=andquot;PasswordIterationsandquot;andgt;Number of iterations to doandlt;/paramandgt;

9: /// andlt;param name=andquot;InitialVectorandquot;andgt;Needs to be 16 ASCII characters longandlt;/paramandgt;

10: /// andlt;param name=andquot;KeySizeandquot;andgt;Can be 128, 192, or 256andlt;/paramandgt;

11: /// andlt;returnsandgt;An encrypted stringandlt;/returnsandgt;

12: public static string Encrypt(string PlainText, string Password,

13: string Salt = andquot;Kosherandquot;, string HashAlgorithm = andquot;SHA1andquot;,

14: int PasswordIterations = 2, string InitialVector = andquot;OFRna73m*aze01xYandquot;,

15: int KeySize = 256)

16: {

17: if (string.IsNullOrEmpty(PlainText))

18: return andquot;andquot;;

19: if (string.IsNullOrEmpty(Password))

20: throw new ArgumentNullException(andquot;Passwordandquot;);

21: if(string.IsNullOrEmpty(Salt))

22: throw new ArgumentNullException(andquot;Saltandquot;);

23: if(string.IsNullOrEmpty(HashAlgorithm))

24: throw new ArgumentNullException(andquot;HashAlgorithmandquot;);

25: if (string.IsNullOrEmpty(InitialVector))

26: throw new ArgumentNullException(andquot;InitialVectorandquot;);

27: byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(InitialVector);

28: byte[] SaltValueBytes = Encoding.ASCII.GetBytes(Salt);

29: byte[] PlainTextBytes = Encoding.UTF8.GetBytes(PlainText);

30: PasswordDeriveBytes DerivedPassword = new PasswordDeriveBytes(Password, SaltValueBytes, HashAlgorithm, PasswordIterations);

31: byte[] KeyBytes = DerivedPassword.GetBytes(KeySize / 8);

32: RijndaelManaged SymmetricKey = new RijndaelManaged();

33: SymmetricKey.Mode = CipherMode.CBC;

34: byte[] CipherTextBytes = null;

35: using (ICryptoTransform Encryptor = SymmetricKey.CreateEncryptor(KeyBytes, InitialVectorBytes))

36: {

37: using (MemoryStream MemStream = new MemoryStream())

38: {

39: using (CryptoStream CryptoStream = new CryptoStream(MemStream, Encryptor, CryptoStreamMode.Write))

40: {

41: CryptoStream.Write(PlainTextBytes, 0, PlainTextBytes.Length);

42: CryptoStream.FlushFinalBlock();

43: CipherTextBytes = MemStream.ToArray();

44: MemStream.Close();

45: CryptoStream.Close();

46: }

47: }

48: }

49: SymmetricKey.Clear();

50: return Convert.ToBase64String(CipherTextBytes);

51: }

In fact you had to use different static functions to use other encryption standards (DES, TripleDES, etc). And each of those functions took in different parameters:

DES:

1: public static string Encrypt(string Input, string Key)

vs AES:

1: public static string Encrypt(string PlainText, string Password,

2: string Salt = andquot;Kosherandquot;, string HashAlgorithm = andquot;SHA1andquot;,

3: int PasswordIterations = 2, string InitialVector = andquot;OFRna73m*aze01xYandquot;,

4: int KeySize = 256)

With the newer code though things are different. Instead you can encrypt a string doing this:

1: string Data = andquot;This is a test of the system.andquot;;

2: Data=Data.Encrypt(andquot;Babysfirstkeyandquot;);

Using this function:

1: /// andlt;summaryandgt;

2: /// Encrypts a string

3: /// andlt;/summaryandgt;

4: /// andlt;param name=andquot;Dataandquot;andgt;Text to be encryptedandlt;/paramandgt;

5: /// andlt;param name=andquot;Keyandquot;andgt;Password to encrypt withandlt;/paramandgt;

6: /// andlt;param name=andquot;AlgorithmUsingandquot;andgt;Algorithm to use for encryption (defaults to AES)andlt;/paramandgt;

7: /// andlt;param name=andquot;Saltandquot;andgt;Salt to encrypt withandlt;/paramandgt;

8: /// andlt;param name=andquot;HashAlgorithmandquot;andgt;Can be either SHA1 or MD5andlt;/paramandgt;

9: /// andlt;param name=andquot;PasswordIterationsandquot;andgt;Number of iterations to doandlt;/paramandgt;

10: /// andlt;param name=andquot;InitialVectorandquot;andgt;Needs to be 16 ASCII characters longandlt;/paramandgt;

11: /// andlt;param name=andquot;KeySizeandquot;andgt;Can be 64 (DES only), 128 (AES), 192 (AES and Triple DES), or 256 (AES)andlt;/paramandgt;

12: /// andlt;param name=andquot;EncodingUsingandquot;andgt;Encoding that the original string is using (defaults to UTF8)andlt;/paramandgt;

13: /// andlt;returnsandgt;An encrypted string (Base 64 string)andlt;/returnsandgt;

14: public static string Encrypt(this string Data, string Key,

15: Encoding EncodingUsing = null,

16: SymmetricAlgorithm AlgorithmUsing = null, string Salt = andquot;Kosherandquot;,

17: string HashAlgorithm = andquot;SHA1andquot;, int PasswordIterations = 2,

18: string InitialVector = andquot;OFRna73m*aze01xYandquot;, int KeySize = 256)

19: {

20: if (string.IsNullOrEmpty(Data))

21: return andquot;andquot;;

22: return Data.ToByteArray(EncodingUsing).Encrypt(Key, AlgorithmUsing, Salt, HashAlgorithm, PasswordIterations, InitialVector, KeySize).ToBase64String();

23: }

24:

25: /// andlt;summaryandgt;

26: /// Encrypts a byte array

27: /// andlt;/summaryandgt;

28: /// andlt;param name=andquot;Dataandquot;andgt;Data to be encryptedandlt;/paramandgt;

29: /// andlt;param name=andquot;Keyandquot;andgt;Password to encrypt withandlt;/paramandgt;

30: /// andlt;param name=andquot;AlgorithmUsingandquot;andgt;Algorithm to use for encryption (defaults to AES)andlt;/paramandgt;

31: /// andlt;param name=andquot;Saltandquot;andgt;Salt to encrypt withandlt;/paramandgt;

32: /// andlt;param name=andquot;HashAlgorithmandquot;andgt;Can be either SHA1 or MD5andlt;/paramandgt;

33: /// andlt;param name=andquot;PasswordIterationsandquot;andgt;Number of iterations to doandlt;/paramandgt;

34: /// andlt;param name=andquot;InitialVectorandquot;andgt;Needs to be 16 ASCII characters longandlt;/paramandgt;

35: /// andlt;param name=andquot;KeySizeandquot;andgt;Can be 64 (DES only), 128 (AES), 192 (AES and Triple DES), or 256 (AES)andlt;/paramandgt;

36: /// andlt;returnsandgt;An encrypted byte arrayandlt;/returnsandgt;

37: public static byte[] Encrypt(this byte[] Data, string Key,

38: SymmetricAlgorithm AlgorithmUsing = null, string Salt = andquot;Kosherandquot;,

39: string HashAlgorithm = andquot;SHA1andquot;, int PasswordIterations = 2,

40: string InitialVector = andquot;OFRna73m*aze01xYandquot;, int KeySize = 256)

41: {

42: if (Data == null)

43: return null;

44: if (AlgorithmUsing == null)

45: AlgorithmUsing = new RijndaelManaged();

46: if (string.IsNullOrEmpty(Key))

47: throw new ArgumentNullException(andquot;Keyandquot;);

48: if (string.IsNullOrEmpty(Salt))

49: throw new ArgumentNullException(andquot;Saltandquot;);

50: if (string.IsNullOrEmpty(HashAlgorithm))

51: throw new ArgumentNullException(andquot;HashAlgorithmandquot;);

52: if (string.IsNullOrEmpty(InitialVector))

53: throw new ArgumentNullException(andquot;InitialVectorandquot;);

54: using (PasswordDeriveBytes DerivedPassword = new PasswordDeriveBytes(Key, Salt.ToByteArray(), HashAlgorithm, PasswordIterations))

55: {

56: using (SymmetricAlgorithm SymmetricKey = AlgorithmUsing)

57: {

58: SymmetricKey.Mode = CipherMode.CBC;

59: byte[] CipherTextBytes = null;

60: using (ICryptoTransform Encryptor = SymmetricKey.CreateEncryptor(DerivedPassword.GetBytes(KeySize / 8), InitialVector.ToByteArray()))

61: {

62: using (MemoryStream MemStream = new MemoryStream())

63: {

64: using (CryptoStream CryptoStream = new CryptoStream(MemStream, Encryptor, CryptoStreamMode.Write))

65: {

66: CryptoStream.Write(Data, 0, Data.Length);

67: CryptoStream.FlushFinalBlock();

68: CipherTextBytes = MemStream.ToArray();

69: MemStream.Close();

70: CryptoStream.Close();

71: }

72: }

73: }

74: SymmetricKey.Clear();

75: return CipherTextBytes;

76: }

77: }

78: }

Well, in reality 2 functions, plus there are a number of calls to other extension methods that I’ve added called through out. Anyway, with the newer code most of the static functions have been moved to being extension methods (where it makes sense anyway). On top of that many of the functions now work on multiple data types (the encryption functions now work on strings and byte arrays for example). I've also tried to give decent default values for everything (when I can) and tried to make things a bit more generic. For instance the one encryption method above does AES, DES, and TripleDES (along with RC2 and any other class that inherits from SymmetricAlgorithm). All you do is pass in the algorithm class you want to use and it handles the rest (and if you don't pass in anything it defaults to AES). This should make using the code much simpler and more succinct than it was in the past.

The same thing is going on for a number of classes (FileManager is now a series of extensions for the FileInfo and DirectoryInfo classes, Serialization class is now extension methods added onto byte arrays, XmlDocuments, etc). And in each of these instances I'm trying to reduce the amount of code that you will need to write. At least for me it's easier to write:

1: TestClass TestItem=new TestClass();

2: TestItem.ToXML(@andquot;.\Testing\Test.xmlandquot;);

than

1: TestClass TestObject=new TestClass();

2: Utilities.IO.Serialization.ObjectToXML(TestObject,@andquot;.\Testing\Test.xmlandquot;);

Plus it gives it a nicer fluent interface feel which is easier to follow as I try to make sure that everything returns some value that you can act on. Anyway, if you're at all interested in influencing the direction that I go with this then drop into the CodePlex site and let me know your opinion in the discussions section and next time I'll be starting a series on building a Dependency Injection library.

Why You Should Sign Your DLLs

James Craig — Sun, 07 Aug 2011 21:26:19 GMT

Generally speaking I do not deal with security issues much. I mean I can set up SSL, set up a form based authentication, etc. the basic stuff. But one thing that I almost always do in my applications is sign the DLLs. The main reason I do this is because of a former coworker of mine. You see, years ago I worked with a guy who liked to mess with people. He liked to put new hires through a “hazing” ritual. Specifically he had this application that he wrote that would analyze a DLL, find the class/functions that were available in the DLL, and generate some default classes with the same names (basically he generated stubs). He would do this with one of the third party DLLs that we were using, slip it onto your machine, and come over and tell you that whatever app you had just shipped wasn’t working correctly. You’d start up the app and nothing would work. It would start up fine, but everything from the one DLL would return null/default values. The reason he was able to do this was because the way that DLLs are loaded is dumb. I don’t mean it’s done in a stupid way, well it is sort of. When you link to a DLL that is named MyDLLs.dll, it will load anything as long as it has the same name by default. As an example, let’s assume that I have an app called TestApp: 1: using System;

2: using System.Collections.Generic;

3: using System.Linq;

4: using System.Text;

5: using Utilities.DataTypes.Patterns;

6:

7: namespace TestApp

8: {

9: class Program

10: {

11: static void Main(string[] args)

12: {

13: Factoryandlt;string, stringandgt; Factory = new Factoryandlt;string, stringandgt;();

14: Factory.Register(andquot;Aandquot;, andquot;Bandquot;);

15: Console.WriteLine(Factory.Create(andquot;Aandquot;));

16: Console.ReadLine();

17: }

18: }

19: }

It’s simple enough, all it’s doing is using the default System DLLs and one extra DLL called Utilities (and yes, it’s a class from my utility library but let’s assume that it’s not). The Utilities DLL has a class called Factory:

1: using System;

2: using System.Collections.Generic;

3: using System.Linq;

4: using System.Text;

5:

6: namespace Utilities.DataTypes.Patterns

7: {

8: public class Factoryandlt;Key, Tandgt;

9: {

10: #region Constructors

11:

12: /// andlt;summaryandgt;

13: /// Constructor

14: /// andlt;/summaryandgt;

15: public Factory()

16: {

17: Constructors = new Dictionaryandlt;Key, Funcandlt;Tandgt;andgt;();

18: }

19:

20: #endregion

21:

22: #region Protected Variables

23:

24: /// andlt;summaryandgt;

25: /// List of constructors/initializers

26: /// andlt;/summaryandgt;

27: protected virtual Dictionaryandlt;Key, Funcandlt;Tandgt;andgt; Constructors { get; set; }

28:

29: #endregion

30:

31: #region Public Functions

32:

33: /// andlt;summaryandgt;

34: /// Registers an item

35: /// andlt;/summaryandgt;

36: /// andlt;param name=andquot;Keyandquot;andgt;Item to registerandlt;/paramandgt;

37: /// andlt;param name=andquot;Resultandquot;andgt;The object to be returnedandlt;/paramandgt;

38: public virtual void Register(Key Key, T Result)

39: {

40: if (Exists(Key))

41: Constructors[Key] = new Funcandlt;Tandgt;(() =andgt; Result);

42: else

43: Constructors.Add(Key, new Funcandlt;Tandgt;(() =andgt; Result));

44: }

45:

46: /// andlt;summaryandgt;

47: /// Registers an item

48: /// andlt;/summaryandgt;

49: /// andlt;param name=andquot;Keyandquot;andgt;Item to registerandlt;/paramandgt;

50: /// andlt;param name=andquot;Constructorandquot;andgt;The function to call when creating the itemandlt;/paramandgt;

51: public virtual void Register(Key Key, Funcandlt;Tandgt; Constructor)

52: {

53: if (Exists(Key))

54: Constructors[Key] = Constructor;

55: else

56: Constructors.Add(Key, Constructor);

57: }

58:

59: /// andlt;summaryandgt;

60: /// Creates an instance associated with the key

61: /// andlt;/summaryandgt;

62: /// andlt;param name=andquot;Keyandquot;andgt;Registered itemandlt;/paramandgt;

63: /// andlt;returnsandgt;The type returned by the initializerandlt;/returnsandgt;

64: public virtual T Create(Key Key)

65: {

66: if (Exists(Key))

67: return Constructors[Key]();

68: return default(T);

69: }

70:

71: /// andlt;summaryandgt;

72: /// Determines if a key has been registered

73: /// andlt;/summaryandgt;

74: /// andlt;param name=andquot;Keyandquot;andgt;Key to checkandlt;/paramandgt;

75: /// andlt;returnsandgt;True if it exists, false otherwiseandlt;/returnsandgt;

76: public virtual bool Exists(Key Key)

77: {

78: return Constructors.ContainsKey(Key);

79: }

80:

81: #endregion

82: }

83: }

If we compile, we get a line on the screen that just says “B”. Now let’s assume we create another DLL, called Utilities.DLL, with a class called Factory, but instead had it look like this:

1: using System;

2: using System.Collections.Generic;

3: using System.Linq;

4: using System.Text;

5:

6: namespace Utilities.DataTypes.Patterns

7: {

8: public class Factoryandlt;Key, Tandgt;

9: {

10: #region Constructors

11:

12: /// andlt;summaryandgt;

13: /// Constructor

14: /// andlt;/summaryandgt;

15: public Factory()

16: {

17: Constructors = new Dictionaryandlt;Key, Funcandlt;Tandgt;andgt;();

18: }

19:

20: #endregion

21:

22: #region Protected Variables

23:

24: /// andlt;summaryandgt;

25: /// List of constructors/initializers

26: /// andlt;/summaryandgt;

27: protected virtual Dictionaryandlt;Key, Funcandlt;Tandgt;andgt; Constructors { get; set; }

28:

29: #endregion

30:

31: #region Public Functions

32:

33: /// andlt;summaryandgt;

34: /// Registers an item

35: /// andlt;/summaryandgt;

36: /// andlt;param name=andquot;Keyandquot;andgt;Item to registerandlt;/paramandgt;

37: /// andlt;param name=andquot;Resultandquot;andgt;The object to be returnedandlt;/paramandgt;

38: public virtual void Register(Key Key, T Result)

39: {

40: if (Exists(Key))

41: Constructors[Key] = () =andgt; MyFunction();

42: else

43: Constructors.Add(Key, () =andgt; MyFunction());

44: }

45:

46: /// andlt;summaryandgt;

47: /// Registers an item

48: /// andlt;/summaryandgt;

49: /// andlt;param name=andquot;Keyandquot;andgt;Item to registerandlt;/paramandgt;

50: /// andlt;param name=andquot;Constructorandquot;andgt;The function to call when creating the itemandlt;/paramandgt;

51: public virtual void Register(Key Key, Funcandlt;Tandgt; Constructor)

52: {

53: if (Exists(Key))

54: Constructors[Key] = () =andgt; MyFunction();

55: else

56: Constructors.Add(Key, () =andgt; MyFunction());

57: }

58:

59: private T MyFunction()

60: {

61: Console.Write(andquot;I deleted something importantandquot;);

62: return default(T);

63: }

64:

65: /// andlt;summaryandgt;

66: /// Creates an instance associated with the key

67: /// andlt;/summaryandgt;

68: /// andlt;param name=andquot;Keyandquot;andgt;Registered itemandlt;/paramandgt;

69: /// andlt;returnsandgt;The type returned by the initializerandlt;/returnsandgt;

70: public virtual T Create(Key Key)

71: {

72: if (Exists(Key))

73: return Constructors[Key]();

74: return default(T);

75: }

76:

77: /// andlt;summaryandgt;

78: /// Determines if a key has been registered

79: /// andlt;/summaryandgt;

80: /// andlt;param name=andquot;Keyandquot;andgt;Key to checkandlt;/paramandgt;

81: /// andlt;returnsandgt;True if it exists, false otherwiseandlt;/returnsandgt;

82: public virtual bool Exists(Key Key)

83: {

84: return Constructors.ContainsKey(Key);

85: }

86:

87: #endregion

88: }

89: }

Instead of having a line that says simply “B”, we’re going to get “I deleted something important”. If I copy this second Utilities.DLL into the location of the first, TestApp will load it without thinking twice. That should make you worry right about now because what if instead of saying “I deleted something important”, I actually went ahead and deleted something important? Now if you sign a DLL (and the other person doesn’t have access to the key), you will not get this issue. Instead you will get a nice error that is thrown saying “can’t load XXXXX.DLL”. If the public keys don’t match, it’s not loaded. If the third party DLLs had been signed my first week at that job would have been a lot easier. So to make things easier on new hires (and to prevent the possibility of some more nefarious possibilities), please sign your DLLs.

Setting Up Hg-Git

James Craig — Thu, 28 Jul 2011 22:22:23 GMT

So apparently it takes the people at CodePlex a little while to make the switch to Mercury from SVN because, as I go to the site now, my code repository is coming up Subversion. It’s only been eight days though since Wade from Chinasoft (who apparently does their tech support) contacted me, and this would fall under low priority, so I’ll give it a little more time but seriously someone needs to automate that process. In the mean time I’ve set up both a bitbucket and github site. Now the bitbucket setup was simple, install TortoiseHg and I’m done. Setting up github was a bit more in depth. I mean I could just set up git, but I hate the command line. Give me a GUI and I’m happy (I know, I’m odd for a programmer). So instead I decided to set up Hg-Git. Hg-Git is a plugin for mercury that allows you to connect to git repositories and it’s kind of a pain to set up. Well not really. It only takes a couple of steps: Install TortoiseHg – It’s here Install Hg-Git – you can use TortoiseHg to get the latest version from the repository here. All you have to do is download it, it’s a bunch of python code so nothing to install. Now we set it up – Open up TortoiseHg’s Hg Workbench, go to File-andgt;Settings-andgt;Edit File (it’s a button on the upper right side). From there we enter the following and save it: [extensions] hggit = Location that you saved Hg-Git to hgext.bookmarks = [ui] ssh = andquot;C:\Program Files\TortoiseHg\TortoisePlink.exeandquot; Once we do that we need to create a public/private key pair. I used PuTTY for this. Just install it and run the PuTTYgen app, hit Generate, and save the public and private key to your hard drive. Once the keys are generated, we need to add our key to github. If you go into your Account Settings, there is a link that says SSH Public Keys on the left side. Once there the middle portion should say Add another public key. Copy and paste the public key that you saved earlier into there and hit save. Now we just need to setup Pageant (it’s installed already at this point). Add a shortcut to the Startup folder with the following: andquot;C:\Program Files\TortoiseHg\Pageant.exeandquot; andquot;Location of the private key that you saved earlierandquot;

From here on you should be able to clone your repository and start pushing code. However I’ve learned that I need to set the master bookmark to whatever I actually want to push for some odd reason. That doesn’t seem like something I should have to do but it is what it is. Anyway, that’s what I went through to get it up and running. For now I’ll be updating the code on those two pages and not the CodePlex page (that will change once they actually update my repository there). So choose whichever you like more and happy coding. Oh and I’ve set it up to link to the Twitter account (sorry for spamming the tests earlier today), so if you want to keep up to date with both my site here and updates as I push them to github/bitbucket you will be able to do that now.

Basic Shortcuts in Visual Studio That I Use

James Craig — Sat, 23 Jul 2011 15:22:19 GMT

So apparently a couple of people have complained about the fact that I have line numbers in the code that I show. Apparently people have been going line by line and deleting the numbers. My first response was “Wow, that’s inefficient… Wait do they not know about column selection?” You see Visual Studio has this little feature that lets you select a column (really a block) of data. All you do is hold down the alt key when selecting something and you can select a column of data. So you do that, select the numbers before my code, and hit delete and you have usable code. And if these guys didn’t know about that little trick, maybe they didn’t know a couple of others in Visual Studio: Hold Alt while selecting = column select mode (don't need to continue holding). ctrl+K, ctrl+C = comment out a section ctrl+K, ctrl+U = uncomment a section ctrl+M, ctrl+O = collapses all regions (functions, etc.) ctrl+M, ctrl+L = shows all regions (functions, etc.) ctrl+. (dot) = Show smart menu (whenever you see that weird blue underline, it brings up a menu of options related) ctrl+N = New file dialog Shift+Alt+Enter = Full screen mode (I only use this when I'm trying to show code to people on a projector or something) ctrl+tab = goes between child windows and brings up the nice andquot;active filesandquot; window so you can pick the file you want (at least in 2010 anyway). F5 = debug (also in break mode causes the execution to continue, but if you don’t know that, that’s rather worrisome) Ctrl+F5 = compiles and runs the app (no debug) Shift+F5 = kills debugging session F4 = displays the properties window ctrl+K,ctrl+D = formats the code in the window Shift+del = deletes a row F12 = Go to definition Those are the ones that I use frequently enough anyway. Or at least ones that I can remember off the top of my head. Anyway hopefully this helps someone out. Try them out and happy coding.

Craigandrsquo;s Utility Library 2.2 Released

James Craig — Wed, 20 Jul 2011 21:49:53 GMT

Today is another release of my utility library. This one contains a number of new additions along with a number of fixes: Additions: 1) CodeGen namespace, which helps with templated text/code generation. 2) Added ability to set free/busy status of appointments. 3) Added IsOfType function to tell if a specific type is a subtype of an interface/base class. 4) Added GetPropertyName function that does a better job when the data type of the property is known. 5) Added basic functions to DataTypeConversion class to convert between SqlDbType to .Net types and vice versa. 6) Added IFluentInterface interface that can be used to hide the ToString, etc. functions. 7) Added MicroORM set of classes, which acts as a simple object to relational mapper (similar to Dapper). 8) Added the ability to run multiple queries in one go in SQLHelper with the NextResult function (skips to the next result set). 9) Added ExecuteDataSet and ExecuteXmlReader functions for SQLHelper (to bring it more in line with the old SqlHelper class that Microsoft put out a while back). 10) Added DbTypeToNetType and NetTypeToDbType functions that convert from DbType to .Net types and vice versa. (also added DbTypeToSqlDbType and SqlDbTypeToDbType to convert between SqlDbType and DbType) 11) Simplified and merged ObjectCartographer project code. Now is housed in the Utilities.DataMapper namespace. 12) Added GetPropertySetter and GetPropertyGetter functions to generate Func and Actions on the fly for a property. 13) Added GetProperty function when type not known at compile time. 14) Added ; as separator in EmailSender class. 15) Added JSON serialization. 16) Merged YABOV project code. Now is housed in the Utilities.Validation namespace. 17) Merged Blammo.Net project code. Now is housed in the Utilities.IO.Logging namespace. 18) Merged Gestalt.Net project code. Now is housed in the Utilities.Configuration namespace. 19) Added function to FileManager that allows for setting attributes on a directory/files within it. 20) Added function to Reflection class that creates one instance of all classes that it finds of a specific interface/base class. 21) Added functions to load assemblies from a directory and create objects from a directory. 22) Added ability to search for file types in FileManager. 23) Merged Aspectus project code. Now housed in the Utilities.Reflection.AOP namespace. 24) Merged DotCache project code. Now housed in the Utilities.Caching namespace. 25) Merged Hateraide project code. Now housed in the Utilities.ORM namespace. 26) Added generic version of ExecuteScaler function in SQLHelper. Fixes/Improvements: 1) Fixed minor issues with CSS StripWhitespace function. 2) Fixed minor issues with Javascript Minify function (now respects special comments as described by Yahoo Compressor documentation: http://developer.yahoo.com/yui/compressor/css.html). 3) Fixed issue with delimited files containing $. 4) Fixed issue in EmailSender if email addresses are empty/blank. 5) Improved the IsIEnumerable function to remove redundant code. 6) Rewrote SQLHelper class. Now uses DbFactories so more than just SQL Server is supported. 7) Added better parameter handling to SQLHelper. 8) Improved GetPropertyName function. 9) Added automatic opening/closing of a connection on functions where it is required (SQLHelper) 10) Added checks to SQLHelper for opening/closing a connection. 11) Added check in SQLHelper that if a field wasn't returned that the default value is instead returned. 12) Fixed various issues in SQLServer class. And that’s just the stuff that I was able to remember. I’m pretty sure that there is even more in this release. And that’s not the end of my news. You see I’ve also finally sent in the request to CodePlex to switch the repository over to Mercury from SVN. Once that actually goes through I’ll be adding it to BitBucket, Google Code, etc. as mirror sites. I’ve also merged a number of my projects in with this release (so if you were using them, you should probably take a look at the utility library as it was probably moved there). This leads me to the future of this project. This release is going to be the last in the 2.0 line. The reason is not that I’m abandoning the project. It’s sort of the opposite in that I plan to rewrite a good chunk of it. For instance the Image class is huge, static, etc. It needs to be simplified. The same goes for a number of classes. On top of that much of the initial code was written prior to .Net 3.0 being out. Many changes to C# have been added and I’ve been unable to keep up with all of it in regard to the library. Sadly as time is going on it’s becoming more difficult to update/maintain. On top of that you may have noticed but there are no unit tests with the code. Up until recently the unit tests that I use are related to my work (the main reason I wrote most of the code was for my job so it makes sense). Since that was the case I couldn’t release them. I want to change that. Also up until now the code’s been a bit closed off to contributions, once again I want to change that also (hence I’m switching to Hg, which is a bit more conducive to that). In the coming days I plan to put up a few more details on the CodePlex site with regard to actual changes that I have planned, but for now download the code, leave feedback, and happy coding.

Web Page to Get Basic Information from SharePoint

James Craig — Sun, 03 Jul 2011 18:54:34 GMT

As of late I’ve been working mostly on a SharePoint install at work. We use it for our extranet already and we’re just planning on switching our intranet over to it. One of the biggest issues that we’ve run into with the extranet is simply figuring out what the heck we had out there. I had access to log into the server along with a couple of other admins but when our help desk would get a call, they’d be out of luck. So I made a small app to give them basic information about any site collection that someone might call about. Since it’s generic enough, I figured I might as well share it with the world: 1:

2: andlt;html xmlns=andquot;http://www.w3.org/1999/xhtmlandquot;andgt;

3: andlt;head runat=andquot;serverandquot;andgt;

4: andlt;titleandgt;SharePoint Manager Overviewandlt;/titleandgt;

5: andlt;/headandgt;

6: andlt;bodyandgt;

7: andlt;form id=andquot;form1andquot; runat=andquot;serverandquot;andgt;

8: andlt;tableandgt;

9: andlt;theadandgt;

10: andlt;trandgt;

11: andlt;thandgt;Site Collectionsandlt;/thandgt;

12: andlt;thandgt;Web Sitesandlt;/thandgt;

13: andlt;/trandgt;

14: andlt;/theadandgt;

15: andlt;tbodyandgt;

16: andlt;trandgt;

17: andlt;tdandgt;

18: andlt;asp:DropDownList ID=andquot;Sitesandquot; runat=andquot;serverandquot;

19: onselectedindexchanged=andquot;Sites_SelectedIndexChangedandquot; autopostback=andquot;trueandquot;andgt;

20: andlt;/asp:DropDownListandgt;

21: andlt;/tdandgt;

22: andlt;tdandgt;

23: andlt;asp:DropDownList ID=andquot;SubSitesandquot; runat=andquot;serverandquot;

24: onselectedindexchanged=andquot;SubSites_SelectedIndexChangedandquot; autopostback=andquot;trueandquot;andgt;

25: andlt;/asp:DropDownListandgt;

26: andlt;/tdandgt;

27: andlt;/trandgt;

28: andlt;/tbodyandgt;

29: andlt;/tableandgt;

30: andlt;tableandgt;

31: andlt;theadandgt;

32: andlt;trandgt;

33: andlt;thandgt;Basic Informationandlt;/thandgt;

34: andlt;/trandgt;

35: andlt;/theadandgt;

36: andlt;tbodyandgt;

37: andlt;trandgt;

38: andlt;tdandgt;

39: andlt;div id=andquot;Testandquot; runat=andquot;serverandquot;andgt;

40:

41: andlt;/divandgt;

42: andlt;/tdandgt;

43: andlt;/trandgt;

44: andlt;/tbodyandgt;

45: andlt;/tableandgt;

46: andlt;tableandgt;

47: andlt;theadandgt;

48: andlt;trandgt;

49: andlt;thandgt;Unused Sitesandlt;/thandgt;

50: andlt;/trandgt;

51: andlt;/theadandgt;

52: andlt;tbodyandgt;

53: andlt;trandgt;

54: andlt;tdandgt;

55: andlt;div id=andquot;Unusedandquot; runat=andquot;serverandquot;andgt;

56:

57: andlt;/divandgt;

58: andlt;/tdandgt;

59: andlt;/trandgt;

60: andlt;/tbodyandgt;

61: andlt;/tableandgt;

62:

63: andlt;/formandgt;

64: andlt;/bodyandgt;

65: andlt;/htmlandgt;

And along with that, we have a bit of code behind:

1: using System;

2: using System.Collections.Generic;

3: using System.Linq;

4: using System.Web;

5: using System.Web.UI;

6: using System.Web.UI.WebControls;

7: using Microsoft.SharePoint;

8: using Microsoft.SharePoint.Administration;

9: using System.Data;

10:

11: namespace SiteInfo

12: {

13: public partial class _Default : System.Web.UI.Page

14: {

15: protected void Page_Load(object sender, EventArgs e)

16: {

17: if (!Page.IsPostBack)

18: LoadLists();

19: }

20:

21: private void LoadLists()

22: {

23: try

24: {

25: Sites.Items.Clear();

26: Sites.Items.Add(new ListItem(andquot; andquot;, andquot;andquot;));

27: using (SPSite WebSite = new SPSite(andquot;LOCAL SITE LOCATIONandquot;))

28: {

29: foreach (SPSite TempSite in WebSite.WebApplication.Sites)

30: {

31: Sites.Items.Add(new ListItem(TempSite.Url, TempSite.ID.ToString()));

32: if (TempSite.LastContentModifiedDate.CompareTo(DateTime.Now.AddDays(-30)) andlt; 0)

33: Unused.InnerHtml += andquot;andlt;a href=\andquot;andquot; + TempSite.Url + andquot;\andquot;andgt;andquot; + TempSite.Url + andquot;andlt;/aandgt;andlt;br /andgt;andquot;;

34: }

35: }

36: }

37: catch (Exception a) { Test.InnerHtml = a.ToString(); }

38: }

39:

40: protected void Sites_SelectedIndexChanged(object sender, EventArgs e)

41: {

42: try

43: {

44: SubSites.Items.Clear();

45: SubSites.Items.Add(new ListItem(andquot; andquot;, andquot;andquot;));

46: if (string.IsNullOrEmpty(Sites.SelectedValue))

47: return;

48: using (SPSite TempSite = new SPSite(Guid.Parse(Sites.SelectedValue)))

49: {

50: foreach (SPWeb Web in TempSite.AllWebs)

51: {

52: if (Web != null)

53: {

54: SubSites.Items.Add(new ListItem(Web.Title, Web.ID.ToString()));

55: }

56: }

57: }

58: }

59: catch (Exception a) { Test.InnerHtml = a.ToString(); }

60: }

61:

62: protected void SubSites_SelectedIndexChanged(object sender, EventArgs e)

63: {

64: try

65: {

66: if (string.IsNullOrEmpty(Sites.SelectedValue))

67: return;

68: if (string.IsNullOrEmpty(SubSites.SelectedValue))

69: return;

70: Guid TempGuid = Guid.Parse(SubSites.SelectedValue);

71: using (SPSite TempSite = new SPSite(Guid.Parse(Sites.SelectedValue)))

72: {

73: Test.InnerHtml = andquot;andlt;tableandgt;andquot;;

74: Test.InnerHtml += andquot;andlt;trandgt;andlt;tdandgt;Site collection URL: andlt;/tdandgt;andlt;tdandgt;andlt;a href=\andquot;andquot; + TempSite.Url + andquot;\andquot;andgt;andquot; + TempSite.Url + andquot;andlt;/aandgt;andlt;/tdandgt;andlt;/trandgt;andquot;;

75: Test.InnerHtml += andquot;andlt;trandgt;andlt;tdandgt;Site collection owner: andlt;/tdandgt;andlt;tdandgt;andquot; + TempSite.Owner.Name + andquot;andlt;/tdandgt;andlt;/trandgt;andquot;;

76: Test.InnerHtml += andquot;andlt;trandgt;andlt;tdandgt;Site collection last modified: andlt;/tdandgt;andlt;tdandgt;andquot; + TempSite.LastContentModifiedDate + andquot;andlt;/tdandgt;andlt;/trandgt;andquot;;

77: Test.InnerHtml += andquot;andlt;trandgt;andlt;tdandgt;Site collection size (in MB): andlt;/tdandgt;andlt;tdandgt;andquot; + (TempSite.Usage.Storage / 1048576).ToString() + andquot;andlt;/tdandgt;andlt;/trandgt;andquot;;

78: using (SPWeb Web = TempSite.OpenWeb(TempGuid))

79: {

80: if (Web != null)

81: {

82: Test.InnerHtml += andquot;andlt;trandgt;andlt;tdandgt;Web site title: andlt;/tdandgt;andlt;tdandgt;andquot; + Web.Title + andquot;andlt;/tdandgt;andlt;/trandgt;andquot;;

83: Test.InnerHtml += andquot;andlt;trandgt;andlt;tdandgt;Web site URL: andlt;/tdandgt;andlt;tdandgt;andlt;a href=\andquot;andquot; + Web.Url + andquot;\andquot;andgt;andquot; + Web.Url + andquot;andlt;/aandgt;andlt;/tdandgt;andlt;/trandgt;andquot;;

84: Test.InnerHtml += andquot;andlt;trandgt;andlt;tdandgt;Web site description: andlt;/tdandgt;andlt;tdandgt;andquot; + Web.Description + andquot;andlt;/tdandgt;andlt;/trandgt;andquot;;

85: Test.InnerHtml += andquot;andlt;trandgt;andlt;tdandgt;Web site date created: andlt;/tdandgt;andlt;tdandgt;andquot; + Web.Created + andquot;andlt;/tdandgt;andlt;/trandgt;andquot;;

86: Test.InnerHtml += andquot;andlt;trandgt;andlt;td colspan=\andquot;2\andquot;andgt;andlt;bandgt;Users: andlt;/bandgt;andlt;/tdandgt;andquot;;

87: foreach (SPUser User in Web.AllUsers)

88: {

89: Test.InnerHtml += andquot;andlt;trandgt;andlt;td colspan=\andquot;2\andquot;andgt;andlt;a href=\andquot;mailto:andquot; + User.Email + andquot;\andquot;andgt;andquot; + User.Name + andquot;andlt;/aandgt;andlt;/tdandgt;andlt;/trandgt;andquot;;

90: }

91: Test.InnerHtml += andquot;andlt;trandgt;andlt;td colspan=\andquot;2\andquot;andgt;andlt;bandgt;Properties: andlt;/bandgt;andlt;/tdandgt;andquot;;

92: foreach (object Key in Web.AllProperties.Keys)

93: {

94: Test.InnerHtml += andquot;andlt;trandgt;andlt;tdandgt;andquot; + Key.ToString() + andquot;andlt;/tdandgt;andlt;tdandgt;andquot; + Web.AllProperties[Key].ToString() + andquot;andlt;/tdandgt;andlt;/trandgt;andquot;;

95: }

96: }

97: }

98: Test.InnerHtml += andquot;andlt;/tableandgt;andquot;;

99: }

100: }

101: catch (Exception a) { Test.InnerHtml = a.ToString(); }

102: }

103: }

104: }

And that was all there was to it. With a minimal amount of code I was able to give our help desk at least a decent amount of info to help them with any calls that they get. So try it out, leave feedback, and happy coding.

Major Rework Happening

James Craig — Mon, 27 Jun 2011 20:56:07 GMT

So apparently working nonstop on a SharePoint deployment gives me little time to code (other than a function here, a fix there)... In the mean time I've come to one conclusion, namely that I have too many projects. If I look at my Libraries folder (which contains a number of items that I've released on CodePlex, SourceForge, etc. and a number of items that I haven't released), I see 67 projects. That's 67 various projects that I've used in one form or another, not including their unit tests (which I usually separate out in another project), and I usually have a test app that I use for testing the concept for the library. I have a tendency to start coding based on my notes, try using it in a mini app, and if it feels awkward I refactor, etc. Anyway, when you add it all up we're looking at about 139 projects... I’m not even going to get into the number of lines of code, but let’s just say it takes a while to compile things (even longer if I do a batch build of debug and release). I have an IoC container, a library for procedurally generated textures, a web framework, etc. None of them made it out to the public, but they’re there. Since this is the case, I've decided to get rid of my various libraries. Well, not get rid of, but instead I'm going to merge anything that I find of interest in with my utility library (with the exception of MoonUnit and Optimizer Prime). Once everything is merged, I'm going to do a release. After that, I'm going to rework my utility library a bit. You see I started work on the utility library just before .Net 3.0 came out. So a number of classes are a bit dated. Plus I have classes that aren’t needed/used any more that I plan on getting rid of. Also I finally (it only took a year) got approval to move things to Mercurial. So if you like SVN that's bad news. If you like Hg, it's good news. So there you have it, I haven't posted anything because work hasn't been giving me anything interesting and I'm stuck in a bit of a rewrite on my own projects (but I'm nearing completion on both, so hopefully things will pick up).