Re: Writing XML file from threads - URGENT - - C# Discussion Boards

Richard MacCutchan8-Mar-11 9:57

8-Mar-11 9:57

Thanks, once I get to grips with WPF properly I'll have a closer look.

I must get a clever new signature for 2011.

Pete O'Hanlon8-Mar-11 21:14

Pete O'Hanlon

8-Mar-11 21:14

Let me correct those downvotes. I'm not sure who thought this part of the thread should be downvoted, but I bet I can compensate for them.

I'm not a stalker, I just know things. Oh by the way, you're out of milk.

Forgive your enemies - it messes with their heads

My blog | My articles | MoXAML PowerToys | Onyx

Richard MacCutchan8-Mar-11 21:29

8-Mar-11 21:29

Thanks again, I returned the compliment. I do wonder at the mentality of some of the people who visit this site.

I must get a clever new signature for 2011.

Andy Brummer8-Mar-11 16:16

Andy Brummer

8-Mar-11 16:16

Did you get your issue resolved? I think you need to right click on references, click add, click extensions and scroll down to the assembly with the classes you need. Also after you build open the bin directory and make sure that assembly is in the directory.

I assume you are trying to create an app that uses the templates outside of visual studio?

Curvature of the Mind now with 3D

Writing XML file from threads - URGENT -

SolarEx8-Mar-11 21:36

SolarEx

8-Mar-11 21:36

Still not resolved.

So far once my code is generated I remove the code inside my template.

As I said in my first post the assembly required is VisualStudio.

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

I check several time but there is nothing looking like.

Although the errors target on my template, I almost assume that it's not coming from there because It was working before.

Below my template perhaps there is something obvious:

<#@ 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;
}
#>

moums7-Mar-11 21:56

7-Mar-11 21:56

Hi guys

what zup ???? Poke tongue | ;-P

i have a big problem with thread and xml......i'm trying to write in a xml file from thread so i created a class i called them "Xmlwriter"

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;


namespace xmlWriter_test
{
    class Xmlwriter
    {
        public XmlTextWriter txtWriter { get; set; }
        public string xmlPath { get; set; }
        public Object thislock = new Object();

        public Xmlwriter(string path)
        {
            xmlPath = path;
            txtWriter = new XmlTextWriter(path, null);
        }
        public void writeElement(string element, string data)
        {
            try
            {
                lock (thislock)
                {
                    //txtWriter.WriteStartDocument();
                    txtWriter.WriteStartElement(element);
                    txtWriter.WriteString(data);
                    txtWriter.WriteEndElement();
                    Console.WriteLine("good job !!");
                    //txtWriter.WriteEndDocument();
                }
            }
            catch (InvalidOperationException e)
            {
                Console.WriteLine("erreur :" + e.Message);
            }
        }
        public void startDocument()
        {
            txtWriter.WriteStartDocument();
        }
        public void endDocument()
        {
            try
            {
                txtWriter.WriteEndDocument();
            }
            catch (ArgumentException arg)
            { Console.WriteLine("erreur :" + arg.Message); }
        }
        public void closeDocument()
        {
            txtWriter.Close();
        }
    }
}

and this is my Main class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Data.OleDb;
using System.Data;
using System.Threading;

namespace xmlWriter_test
{
    class Program
    {
        static int i = 0;
        static Xmlwriter wifixmlWriter = new Xmlwriter(@"D:\wifi_test.xml");

        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();
        }

        static public void background()
        {
            //just looop xD
            while (i<50)
            {
                Console.WriteLine("i = {0}", i++);
                //writing in the xml file
                wifixmlWriter.writeElement("hello", "i = " + i);
 
            }
        }
    }
}

that's work for the first iteration and bug after that xD i don't know why .....
and here is what i get at the end ^^
le jeton StartElement dans l'état Error générera un document XML non valid
in english = " the startElement generate an invalid XML document !!!!!!
Dead | X|

thx fr help

OriginalGriff7-Mar-11 22:08

OriginalGriff

7-Mar-11 22:08

I'll get round to looking at your code, but there are about 173 items ahead of it in my priority list: Yours is just after "pick my nose" and "shave the cat".

Real men don't use instructions. They are only the manufacturers opinion on how to put the thing together.

Manfred R. Bihy: "Looks as if OP is learning resistant."

Richard MacCutchan7-Mar-11 22:11

7-Mar-11 22:11

I must get a clever new signature for 2011.

Pete O'Hanlon7-Mar-11 23:11

Pete O'Hanlon

7-Mar-11 23:11

Don't get your multitasking wrong. It would be wrong to pick the cats nose.

I'm not a stalker, I just know things. Oh by the way, you're out of milk.

Forgive your enemies - it messes with their heads

My blog | My articles | MoXAML PowerToys | Onyx

OriginalGriff7-Mar-11 23:15

OriginalGriff

7-Mar-11 23:15

On so many levels! Laugh | :laugh:

Real men don't use instructions. They are only the manufacturers opinion on how to put the thing together.

Manfred R. Bihy: "Looks as if OP is learning resistant."

Richard MacCutchan7-Mar-11 22:10

7-Mar-11 22:10

Why are you running the XmlWriter in a separate thread? Try removing all the thread related code and run it as a normal app to see whether that works.

I must get a clever new signature for 2011.

moums7-Mar-11 22:20

7-Mar-11 22:20

thx for answers Smile | :)

that's work without thread but i must do it in tread xD ...... (this code is just for test ....my real app work in thread to get URL from navigators and i have to write the result in xml file )

or my be i should create a delegate nd invoke them from thread ????

Richard MacCutchan7-Mar-11 22:28

7-Mar-11 22:28

Looking quickly at your code I do not see any synchronization between the main and background thread, perhaps you are breaking in to the worker thread too soon.

I must get a clever new signature for 2011.

moums7-Mar-11 22:37

7-Mar-11 22:37

yes..i think so .... im wondering if i can force the execution of the 3 instructions writeStartElement - writeString - writeEndElement in the same iteration Frown | :(

............ do u know how to do dat ^^

Richard MacCutchan8-Mar-11 0:03

8-Mar-11 0:03

Look at your code:

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();
}

You are breaking into a thread and arbitrarily ending the document. You need to synchronise with the thread so that endDocument() is not called until all the elements have been written.

I must get a clever new signature for 2011.

moums8-Mar-11 0:10

8-Mar-11 0:10

thx dude

the problem was in the root element ( i forgot the root xD when starting the xmlDocument )

its working now Smile | :)

thx 4 help Wink | ;)

J a a n s7-Mar-11 22:56

J a a n s

7-Mar-11 22:56

You are not writing / creating any root element[^]for the XML. Please create the XML in specified format.

"Never put off until run time what you can do at compile time."
- David Gries, in "Compiler Construction for Digital Computers", circa 1969.

moums7-Mar-11 23:43

7-Mar-11 23:43

thx dude ^^ i forgot the root element xD
in main i call "starElement"

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

and i write the data in writeElement method like this

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);
            }
        }

thx again ^^ Big Grin | :-D

_Erik_8-Mar-11 0:42

_Erik_

8-Mar-11 0:42

I see no need for a lock in this code. Every writeElement call is made from the same thread, so you do not have to synchronize it. However, making th.Start() followed by th.Join() does not make too much sense to me... It will work as if it was synchronous.

moums8-Mar-11 1:03