Hi,
ich habe mir jetzt nicht alle Post durchgelesen, wollte aber mal einwerfen, dass in Java ein deutlich "strengeres" Exception-Handling durchgesetzt wird. So muss jede Methode entweder die Exceptions, die auftreten können abfangen oder anzeigen, welche sie werfen könnte. Der Vorteil, der sich aus meiner Sicht daraus ergibt ist, dass nie ein Fehler wirklich die "Oberfläche" erreicht, also unbehandelt durchgereicht wird, was je bei .NET meistens das Programm zum Absturz bringt.

http://java.sun.com/docs/books/tutorial/essential/exceptions/

Beschreibung:
Diese Klasse ermöglicht es scriptartigen C#-Code zu compilieren und auszuführen.

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

using Microsoft.CSharp;
using System.CodeDom.Compiler;
using System.Reflection;
using System.Security;
using System.Security.Policy;
using System.Security.Permissions;
using System.IO;

namespace Lionheart.Scripting
{
    public class ScriptEngine
    {
        private Dictionary<String, Script> Scripts = new Dictionary<string, Script>();
        public List<String> Usings = new List<string>();
        public List<String> CustomDLLPaths = new List<string>();
        public Boolean Override = true;
        public String StartFunction = "Default";

        public ScriptEngine(String StartFunction)
        {
            this.Usings.Add("System");
            this.StartFunction = StartFunction;
        }

        public void LoadScript(String Name, String Code)
        {
            if(!Usings.Contains("System"))
                Usings.Add("System");
            if (Scripts.ContainsKey(Name))
                if (Override)
                    Scripts[Name].Update(Code, this);
                else
                    throw new OverrideException("Override forbidden!");
            else
                Scripts.Add(Name, new Script(Code, this));
        }

        public Boolean RunScript(String Name, Object[] Params)
        {
            if(!Scripts.ContainsKey(Name))
                return false;
            Scripts[Name].Run(Params);
            return true;
        }  
    }

    internal class Script
    {
        private String SavedFile = null;
        private Assembly ScriptAssembly = null;
        private Type ScriptType = null;

        private String Code = null;
        private String StartFunction = "Default";

        internal Script(String Code, ScriptEngine SEngine)
        {
            this.Code = Code;
            this.StartFunction = SEngine.StartFunction;
            CompleteCode(SEngine);
            LoadScript(this.Code, SEngine);
        }

        internal void Update(String Code, ScriptEngine SEngine)
        {
            if (Code == this.Code)
                return;
            Reset();
            this.Code = Code;
            CompleteCode(SEngine);
            LoadScript(this.Code, SEngine);
        }

        private void CompleteCode(ScriptEngine SEngine)
        {
            String TempCode = "";
            foreach (String Using in SEngine.Usings)
                TempCode += "using " + Using + ";" + Environment.NewLine;
            TempCode += "class HeadClass" + Environment.NewLine;
            TempCode += "{" + Environment.NewLine + Code;
            TempCode += Environment.NewLine + "}";
            Code = TempCode;
        }

        private void LoadScript(String Code, ScriptEngine SEngine)
        {
            CSharpCodeProvider Provider = new CSharpCodeProvider();
            CompilerParameters Params = new CompilerParameters();
            Params.GenerateExecutable = false;
            SavedFile = String.Concat(Path.GetTempFileName(), ".dll");
            Params.GenerateInMemory = false;
            Params.OutputAssembly = SavedFile;
            Params.IncludeDebugInformation = true;
            foreach (String DLLPath in SEngine.CustomDLLPaths)
                Params.ReferencedAssemblies.Add(DLLPath);
         

            CompilerResults Result = Provider.CompileAssemblyFromSource(Params, new String[] { Code });
            if (Result.Errors.HasErrors)
            {
                throw new CompilerErrorException("CompilerError", Result.Errors);
            }
            else
            {
                ScriptAssembly = Assembly.LoadFrom(Result.PathToAssembly);
                ScriptType = ScriptAssembly.GetType("HeadClass", false, true);
            }
        }
        internal Object[] Run(Object[] Params)
        {
            if (ScriptAssembly == null || ScriptType == null)
                return Params;
            ScriptType.InvokeMember(StartFunction, (BindingFlags)(BindingFlags.InvokeMethod | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static), null, null, Params);
            return Params;
        }

        internal void Reset()
        {
            ScriptAssembly = null;
            ScriptType = null;
            if (SavedFile != null && SavedFile != "")
            {
                try
                {
                    File.Delete(SavedFile);
                }
                catch (Exception)
                { }
                SavedFile = null;
            }
        }
    }

    //Exceptions

    public class OverrideException : Exception
    {
        public OverrideException(String Message) : base(Message) { }
    }

    public class CompilerErrorException : Exception
    {
        public CompilerErrorCollection Errors;
        private String AddMessage = "";

        public CompilerErrorException(String Message, CompilerErrorCollection Errors)
        {
            this.AddMessage = Message;
            this.Errors = Errors;
        }

        public override string Message
        {
            get
            {
                String Str = "Compiler Error:" + Environment.NewLine;
                Str += AddMessage + Environment.NewLine;
                Str += Errors[0].ErrorText + Environment.NewLine;
                Str += "Z:" + Errors[0].Line + "/S:" + Errors[0].Column;
                return Str;
            }
        }
    }

    
}

Beispiel Intealisierung:

            ScriptEngine = new ScriptEngine("Default");
            ScriptEngine.Usings.Add("Lionheart.Scripting");
            ScriptEngine.CustomDLLPaths.Add("Lionheart.Scripting.dll");
            ScriptEngine.Usings.Add("System.Windows.Forms");
            ScriptEngine.CustomDLLPaths.Add ("C:\\Windows\\Microsoft.NET\\Framework\\v2.0.50727\\System.Windows.Forms.dll");

Beispiel Compilieren:

                ScriptEngine.LoadScript("Test", CodeEditor.Text);
                Object[] Params = {"Out"};
                ScriptEngine.RunScript("Test", Params);

Schlagwörter: Script, C#, Compiler

Schau mal auf google.de:
http://www.google.com/search?hl=en&q=microphone+mute+C%23&btnG=Search

Der erste Eintrag ist nutzlos, hab die nächsten auch mal kurz überflogen und manche hören sich vielversprechend an.

MfG Kevka

"In addition, it installs .NET Framework 2.0 SP1, .NET Framework 2.0 SP2 (with 3.5 SP1) and .NET Framework 3.0 SP1,"

Für mich heißt das, dass 2.0 mitinstalliert wird, was bedeuten würde, dass auf deinen beiden Rechnern eigentlich das gleiche .NET Framework installiert sein sollte: .NET Framework 2.0, 3.0, 3.5 und vielleicht die Servispacks.

Du kannst ja einfach mal kurz in der Systemsteuerung nachschauen.

Nach Adam Riese und Eve Zwerg müsste aber der Installer des 3.5 Frameworks dafür sorgen, dass alle benötigten Komponenten (also auch das 2.0 Framework) in der richtigen Version vorliegen.

MfG Kevka

Also:
.NET Framework 3.5 ohne 2.0 geht irgendwie nicht
(siehe Wikipedia):
"As with .NET Framework 3.0, version 3.5 uses the CLR of version 2.0. In addition, it installs .NET Framework 2.0 SP1, .NET Framework 2.0 SP2 (with 3.5 SP1) and .NET Framework 3.0 SP1,"

MfG Kevka

Hi,
ich bin gerade dabei, ein Programm zu schreiben, welches alle Arten von Spielen auf dem System verhindert.
Leider gibt es noch eine Spielesparte, die ich nicht mit reiner Processüberwachen, Hashes oder Regestrieüberwachung verhindern kann: Die Browsergames

Dazu müssten die entsprechenden Internetseiten gesperrt werden. Dazu sind mir bisher zwei Möglichkeiten eingefallen:*Man überwacht den Fenstertitel aller Browserprozesse oder *das Programm fungiert als Proxy

Das Problem mit der Fenstertitelvariante ist, dass diese nicht sehr "schön" ist und bei wechselnden Titeln neue Signaturen verlangt.
Das Problem mit dem Proxy ist, dass es sehr schwer bis unmöglich wird, über den Proxy, auf Flashinhalte zuzugreifen. Außerdem muss der Proxy in jedem Browser hinterlegt werden, was einen Eingriff in die Config Fies verlangt.

Gibt es noch andere Möglichkeiten?
Kann man auf niedriger Ebene, ähnlich einer Firewall, Zugriff oder Namensauflösung für bestimmte Seiten sperren?

MfG Kevka

Projektsprzifikationen:
Programmiersprache: C#, für Win-API natives C++
Ziel: Soll den Zugriff auf Spiele für min. 90% der Zielgruppe verhindern
Zielgrupe: durchschnittliche Schüler (12-20 Jahre), die meisten ohne nennenswerte technische Erfahrung

das sehe ich ganz genau so - ich rege mich jedes Mal auf, wenn ich merke, dass Leute am Wehrdienst oder am Zivildienst vorbei wollen - nur weil sie keine Lust haben, oder weil es ihnen grad jetzt nicht in den Kram passt. Natürlich kann man über die prinzipielle Gerechtigkeit des Wehr- oder Zivildienstes diskutieren. Aber: Im Augenblick gibt es die Verpflichtung. Und es ist unfair all denen gegenüber die diese Verpflichtung ableisten, jetzt zu sagen, "nein, das sollen andere machen."

A ist Krieg immer schlecht und wir helfen unserer Gesellschaft nicht umbedingt dadurch, dass jungen Männern beigebracht wird, wie man am effektivsten Menschen tötet
B werden nur Männer eingezogen, keine Frauen. Wo bleibt denn da die Gerechtigkeit?

MfG Kevka

PS: Nein, dass sollte keiner machen.

Hi,
ich versuche gerade mit Hilfe des G15 LCD Wrappers ein komfortabel Interface zum Zeichnen auf dem Display zu schreiben. Gerne würde ich dafür die GDI+ Schnittstelle benutzen. Daher bin ich auf die Idee gekommen, dem Object ein Bitmap als Eigenschaft zu geben (die Bitmapklasse ist ja versiegelt).
Über eine Methode kann man nun ein Graphics Object auf das Bitmap erhalten und darauf Zeichnen. Mein Problem ist nur, dass meine Klasse "wissen" muss, wenn etwas neues auf dem Bitmap gezeichnet wurde, um das eigentliche Bild auf dem LCD zu erneuern.
Was fällt euch dazu ein?

MfG Kevka

Ich hab das ganze jetzt nur überflogen, aber vielleicht ist es ja was für dich:
http://streaming.live.com/

C)

List<object> objList = new List<object>();
foreach (object o in objList )
{
    //greife mehrmals auf o zu und tue etwas
}