C# – How to identify a namespace without using a string literal

cinversion-of-controlnamespace

My team has a lot of IOC conventions that look something like…

if (type.Namespace == "My.Fun.Namespace")
{
    // do stuff
}

Of course, maintaining this kind of thing becomes brutal after awhile, and we would rather not. The only option I could think of was to store these all in one place, as string constants or something of that nature, but that isn't a lot better… We have been considering making classes that basically serve as namespace identifiers in order to have almost an anchor type to key off of, like, say…

if (type.Namespace == typeof(My.Fun.Namespace.MarkerClass).Namespace)
{
    // do stuff
}

But that just feels weird. So is there another way to solve this one that we just don't know about? If not, has anyone had any luck with the whole marker class concept?

Best Answer

I think your second approach is the best solution. However, I understand that it looks weired to access the namespace by using another class as a reference. Maybe you can maintain a single file with many namespaces only containing a single interface.

namespace My.Fun.NameSpace
{
    interface IContract { }
}
namespace My.Other.NameSpace
{
    interface IContract { }
}

usage:

if (type.Namespace == typeof(My.Fun.Namespace.IContract).Namespace)
{
    // do stuff
}

Another option I could think of is an extension method

namespace System
{
    public static class TypeExtension
    {
        public static bool IsFromFunNameSpace(this Type type)
        {
             return IsFromNameSpace(type, typeof(My.Fun.NameSpace.IContract));
        }

        public static bool IsFromOtherNameSpace(this Type type)
        {
            return IsFromNameSpace(type, typeof(My.Other.NameSpace.IContract));
        }

        private bool IsFromNameSpace(Type type, Type contract)
        {
            type.Namespace == contract.NameSpace;
        }
    }
}

usage:

if (type.IsFromFunNameSpace())
{
    // do stuff
}

Anyway your IOC approach looks weired to me. The ultimate solution (which requires you to have access to the source code) would be to just let a class implement an interface (which can be empty)

public interface IFun { }

public class FunnyClass : IFun { }

usage:

if (typeof(IFun).IsAssignableFrom(type))
{
    // do stuff
}

Now you are not limited to a specific namespace

Related Solutions

C# – How to Choose a Good Namespace Name?

The name chosen for a namespace should indicate the functionality made available by types in the namespace. For example, the System.Net.Sockets namespace contains types that enable developers to use sockets to communicate over networks.

The general format for a namespace name is as follows:

<Company>.(<Product>|<Technology>)[.<Feature>][.<Subnamespace>]

For example, Microsoft.WindowsMobile.DirectX.

Do use Pascal casing, and separate namespace components with periods (for example, Microsoft.Office.PowerPoint). If your brand employs nontraditional casing, you should follow the casing defined by your brand, even if it deviates from normal namespace casing.

Consider using plural namespace names where appropriate. For example, use System.Collections instead of System.Collection. Brand names and acronyms are exceptions to this rule, however. For example, use System.IO instead of System.IOs.

Do not use the same name for a namespace and a type in that namespace. For example, do not use Debug for a namespace name and also provide a class named Debug in the same namespace. Several compilers require such types to be fully qualified.

There are lots of Do or Do'not detail on MSDN regarding Naming of namespace, Assemblies etc. Check this out for Namespaces

CFW.CoreSystem.Configuration is better.

The Namespace CFW.CoreSystem.Organizational is pretty good but CFW.CoreSystem.Organization is much better to write.

C# – How to make creating viewmodels at runtime less painful

The issue of dependencies when initiating a new view model can be handled with IOC.

public class MyCustomViewModel{
  private readonly IShoppingCartWebService _cartService;

  private readonly ITimeService _timeService;

  public ProductDTO ProductDTO { get; set; }

  public ProductDetailsViewModel(IShoppingCartWebService cartService, ITimeService timeService){
    _cartService = cartService;
    _timeService = timeService;
  }
}

When setting up the container...

Container.Register<IShoppingCartWebService,ShoppingCartWebSerivce>().As.Singleton();
Container.Register<ITimeService,TimeService>().As.Singleton();
Container.Register<ProductDetailsViewModel>();

When you need your view model:

var viewmodel = Container.Resolve<ProductDetailsViewModel>();
viewmodel.ProductDTO = myProductDTO;

When utilizing a framework such as caliburn micro there is often some form of IOC container already present.

SomeCompositionView view = new SomeCompositionView();
ISomeCompositionViewModel viewModel = IoC.Get<ISomeCompositionViewModel>();
ViewModelBinder.Bind(viewModel, view, null);

Best Answer

Related Solutions

C# – How to Choose a Good Namespace Name?

C# – How to make creating viewmodels at runtime less painful

Related Topic