C#

Error	1	The type or namespace 'VisualStudio' doesn't exist in the namespace 'Microsoft' ( an assembly is missing  ?)

<#@ template language="C#" debug="true" hostspecific="true"#>
<#@ include file="EF.Utility.CS.ttinclude"#>
<#@ output extension=".cs"#><#

CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);

string inputFile = @"..\..\ModelEntities.edmx";
EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string ModelNamespace = loader.GetModelNamespace(inputFile);
string namespaceName = code.VsNamespaceSuggestion();


EntityFrameworkTemplateFileManager fileManager = EntityFrameworkTemplateFileManager.Create(this);

// Write out support code to primary template output file
WriteHeader(fileManager);
BeginNamespace(namespaceName, code);
WriteCustomObservableCollection();
EndNamespace(namespaceName);
    
// Emit Entity Types
foreach (EntityType entity in ItemCollection.GetItems<EntityType>().OrderBy(e => e.Name))
{
    fileManager.StartNewFile(entity.Name + "Repository.cs");
    BeginNamespace(namespaceName, code);
    bool entityHasNullableFKs = entity.NavigationProperties.Any(np => np.GetDependentProperties().Any(p=>ef.IsNullable(p)));
#>

<#=Accessibility.ForType(entity)#> <#=code.SpaceAfter(code.AbstractOption(entity))#>class <#=code.Escape(entity)#>Repository<#=code.StringBefore(" : ", code.Escape(entity.BaseType))#> : I<#=code.Escape(entity)#>Repository
{
		IRepository<<#=code.Escape(entity)#>> repo = new Repository<<#=code.Escape(entity)#>>();

		/// <summary>
		/// Creates the specified <#=code.Escape(entity)#> entity.
		/// </summary>
		/// <param name="entity">The <#=code.Escape(entity)#> entity.</param>
		/// <returns></returns>
		public <#=code.Escape(entity)#> Create(<#=code.Escape(entity)#> entity)
		{
			return repo.Create(entity);
		}

		/// <summary>
        /// Creates all entitis <#=code.Escape(entity)#>.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public <#=code.Escape(entity)#>[] CreateAll(<#=code.Escape(entity)#>[] entities)
        {
            return repo.CreateAll(entities);
        }

		/// <summary>
        /// Updates the specified <#=code.Escape(entity)#> entity.
        /// </summary>
        /// <param name="entity">The <#=code.Escape(entity)#> entity.</param>
        /// <returns></returns>
        public <#=code.Escape(entity)#> Update(<#=code.Escape(entity)#> entity)
        {
            return repo.Update(entity);
        }

		/// <summary>
        /// Updates all entities <#=code.Escape(entity)#>.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public <#=code.Escape(entity)#>[] UpdateAll(<#=code.Escape(entity)#>[] entities)
        {
            return repo.UpdateAll(entities);
        }

        /// <summary>
        /// Deletes the specified entity <#=code.Escape(entity)#> given.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        public <#=code.Escape(entity)#> Delete(<#=code.Escape(entity)#> entity)
        {
            return repo.Delete(entity);
        }

        /// <summary>
        /// Queries the table <#=code.Escape(entity)#> with the specified filter.
        /// </summary>
        /// <param name="filter">The filter.</param>
        /// <returns></returns>
        public IEnumerable<<#=code.Escape(entity)#>> Query(System.Linq.Expressions.Expression<Func<<#=code.Escape(entity)#>, bool>> filter)
        {
            return repo.Query(filter);
        }

        /// <summary>
        /// Gets a singles <#=code.Escape(entity)#> matching the given one.
        /// </summary>
        /// <param name="predicate">The predicate.</param>
        /// <returns></returns>
        public <#=code.Escape(entity)#> Single(Func<<#=code.Escape(entity)#>, bool> predicate)
        {
            return repo.Single(predicate);
        }

        /// <summary>
        /// Gets the First <#=code.Escape(entity)#> predicate.
        /// </summary>
        /// <param name="predicate">The predicate.</param>
        /// <returns></returns>
        public <#=code.Escape(entity)#> First(Func<<#=code.Escape(entity)#>, bool> predicate)
        {
            return repo.First(predicate);
        }

        /// <summary>
        /// Deletes all <#=code.Escape(entity)#> given.
        /// </summary>
        /// <param name="predicate">The predicate.</param>
        public void DeleteAll(Func<<#=code.Escape(entity)#>, bool> predicate)
        {
            repo.DeleteAll(predicate);
        }

        /// <summary>
        /// Finds the specified <#=code.Escape(entity)#>.
        /// </summary>
        /// <param name="predicate">The predicate.</param>
        /// <returns></returns>
        public IEnumerable<<#=code.Escape(entity)#>> Find(Func<<#=code.Escape(entity)#>, bool> predicate)
        {
            return repo.Find(predicate); 
        }

        /// <summary>
        /// Gets all entities <#=code.Escape(entity)#>.
        /// </summary>
        /// <returns></returns>
        public IEnumerable<<#=code.Escape(entity)#>> GetAll()
        {
            return repo.GetAll(); 
        }

}
<#
    EndNamespace(namespaceName);
}
    
    

foreach (ComplexType complex in ItemCollection.GetItems<ComplexType>().OrderBy(e => e.Name))
{
    fileManager.StartNewFile(complex.Name + ".cs");
    BeginNamespace(namespaceName, code);
#>
<#=Accessibility.ForType(complex)#> partial class <#=code.Escape(complex)#>
{
<#
    region.Begin("Primitive Properties");

    foreach(EdmProperty edmProperty in complex.Properties.Where(p => p.TypeUsage.EdmType is PrimitiveType && p.DeclaringType == complex))
    {
        bool isDefaultValueDefinedInModel = (edmProperty.DefaultValue != null);
#>

    <#=Accessibility.ForProperty(edmProperty)#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
<#
        if (isDefaultValueDefinedInModel)
        {
#>
    {
        <#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get { return <#=code.FieldName(edmProperty)#>; }
        <#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
    }
    private <#=code.Escape(edmProperty.TypeUsage)#> <#=code.FieldName(edmProperty)#><#=code.StringBefore(" = ", code.CreateLiteral(edmProperty.DefaultValue))#>;
<#
        }
        else
        {
#>
    {
        <#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get;
        <#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set;
    }
<#
        }
    }

    region.End();

    region.Begin("Complex Properties");

    foreach(EdmProperty edmProperty in complex.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == complex))
    {
#>

    <#=Accessibility.ForProperty(edmProperty)#> <#=code.Escape(edmProperty.TypeUsage)#> <#=code.Escape(edmProperty)#>
    {
        <#=code.SpaceAfter(Accessibility.ForGetter(edmProperty))#>get { return <#=code.FieldName(edmProperty)#>; }
        <#=code.SpaceAfter(Accessibility.ForSetter(edmProperty))#>set { <#=code.FieldName(edmProperty)#> = value; }
    }
    private <#=code.Escape(edmProperty.TypeUsage)#> <#=code.FieldName(edmProperty)#> = new <#=code.Escape(edmProperty.TypeUsage)#>();
<#
    }

    region.End();
#>
}
<#
    EndNamespace(namespaceName);
}

if (!VerifyTypesAreCaseInsensitiveUnique(ItemCollection))
{
    return "";
}

fileManager.Process();

#>
<#+
void WriteHeader(EntityFrameworkTemplateFileManager fileManager, params string[] extraUsings)
{
    fileManager.StartHeader();
#>
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated from a template.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts; 
using System.Linq.Expressions;
using CJI.FOX.DataLayer.Repository.Interface;

<#=String.Join(String.Empty, extraUsings.Select(u => "using " + u + ";" + Environment.NewLine).ToArray())#>
<#+
    fileManager.EndBlock();
}

void BeginNamespace(string namespaceName, CodeGenerationTools code)
{
    CodeRegion region = new CodeRegion(this);
    if (!String.IsNullOrEmpty(namespaceName))
    {
#>
namespace <#=code.EscapeNamespace(namespaceName)#>
{
<#+
        PushIndent(CodeRegion.GetIndent(1));
    }
}


void EndNamespace(string namespaceName)
{
    if (!String.IsNullOrEmpty(namespaceName))
    {
        PopIndent();
#>
}
<#+
    }
}

bool IsReadWriteAccessibleProperty(EdmMember member)
{
    string setter = Accessibility.ForWriteOnlyProperty(member);
    string getter = Accessibility.ForReadOnlyProperty(member);

    return getter != "private" && getter != "protected" && setter != "private" && setter != "protected";
}

string PropertyVirtualModifier(string accessibility)
{
    return accessibility + (accessibility != "private" ? " virtual" : "");
}

void WriteCustomObservableCollection()
{
#>
<#+
}

bool VerifyTypesAreCaseInsensitiveUnique(EdmItemCollection itemCollection)
{
    Dictionary<string, bool> alreadySeen = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
    foreach(StructuralType type in itemCollection.GetItems<StructuralType>())
    {
        if (!(type is EntityType || type is ComplexType))
        {
            continue;
        }

        if (alreadySeen.ContainsKey(type.FullName))
        {
            Error(String.Format(CultureInfo.CurrentCulture, "This template does not support types that differ only by case, the types {0} are not supported", type.FullName));
            return false;
        }
        else
        {
            alreadySeen.Add(type.FullName, true);
        }

    }

    return true;
}
#>

static void Main(string[] args)
{
    //start document
    wifixmlWriter.startDocument();
    Thread th = new Thread(new ThreadStart(background));
    Console.WriteLine("starting thread...");
    th.Start();

    //end
    th.Join();
    wifixmlWriter.endDocument();
    Console.WriteLine("press any key to quit");
    Console.ReadKey();
}

public void startDocument()
        {
            txtWriter.WriteStartDocument();
            txtWriter.WriteStartElement("Trace");// this is the root xD
                       
        }

public void writeElement(string element, string data)
        {
            try
            {
                lock (thislock)
                {
                      txtWriter.WriteStartElement(element);
                      txtWriter.WriteEndElement();
                      //Console.WriteLine("good job !!");
                      
                }
            }
            catch (InvalidOperationException e)
            {
                Console.WriteLine("erreur :" + e.Message);
            }
        }