NerdonRails

Schonmal über einen OR-Mapper nachgedacht ?

Nur so interessehalber : was ist denn nicht verständlich ? Damit ich auch noch was lern.

Auf One Man Think Tank Gedanken: Event-based Components gibts einige Artikel zu dem Thema EBCs

Natürlich geht das in C# auch kürzer, ich dachte mir: lieber ausführlich und verständlich als kurz und "hä?". Ist ja im zweifel auch nur als Idee zur Implementierung gedacht. Stimmt, aber meine Pause war zu ende und ich dachte mir: hey, lieber ein Test der nur die Aufgabenstellung abdeckt als gar keiner.

Mein Ansatz wäre: public class NameObfuscator { public String Obfuscate(String stringToObfuscate) { String result = String.Empty; Char firstChararcter = this.ExtractFirstChar(stringToObfuscate); Char lastCharacter = this.ExtractLastChar(stringToObfuscate); IEnumerable<Char> charactersInBetween = this.ExtractCharactersInBetween(stringToObfuscate, firstChararcter, lastCharacter); IEnumerable<Char> randomizedCharactersInBetween = this.RandomizeCharacters(charactersInBetween); result = this.ConstructResultString(firstChararcter, lastCharacter, randomizedCharactersInBetween); return result; } private IEnumerable<Char> ExtractCharactersInBetween(String stringToObfuscate, Char firstChararcter, Char lastCharacter) { IEnumerable<Char> charactersInBetween = from current in stringToObfuscate where current != firstChararcter && current != lastCharacter select current; return charactersInBetween; } private Char ExtractFirstChar(String stringToObfuscate) { return (from current in stringToObfuscate select current).FirstOrDefault(); } private Char ExtractLastChar(String stringToObfuscate) { return (from current in stringToObfuscate select current).LastOrDefault(); } private IEnumerable<Char> RandomizeCharacters(IEnumerable<Char> charactersInBetween) { IEnumerable<Char> result = new List<Char>(); result = this.RandomizeOrder(charactersInBetween); do { result = this.RandomizeOrder(charactersInBetween); } while (!charactersInBetween.SequenceEqual(result)); return result; } private IEnumerable<Char> RandomizeOrder(IEnumerable<Char> charactersInBetween) { Random randomizer = new Random(); return charactersInBetween.OrderBy<Char, Int32>(item => randomizer.Next()); } private String ConstructResultString(Char firstCharacter, Char lastCharacter, IEnumerable<Char> charactersInBetween) { String result = String.Empty; result = String.Concat(firstCharacter, new String(charactersInBetween.ToArray()), lastCharacter); return result; } } Der Test dazu: [TestMethod] public void TestThatAWordIsObfuscated() { String testData = "Jacke"; NameObfuscator obfuscator = new NameObfuscator(); String actual = obfuscator.Obfuscate(testData); Assert.IsFalse(testData == actual); Assert.IsTrue(actual.First() == 'J' && actual.Last() == 'e'); Assert.IsTrue(actual.Contains('a') && actual.Contains('c') && actual.Contains('k')); }

bischen mehr information wären hilfreich, kaffeesatzlesen ist nämlich nicht teil meiner profession.

Dem stimme ich zu.

Die TPL besteht nicht nur aus den parallelisierten Schleifen. Einen weiteren Einblick gibt : Parallel Programming: Task Schedulers and Synchronization Context - C# Frequently Asked Questions - Site Home - MSDN Blogs Ich sage nicht, das die TPL das allheilmittel ist, aber es nimmt einem schon einen großen Teil der Sorgen ab, die man sonst in Sachen Threading befürchten muss. Weiterhin bestimmt laut MSDN soweit ich es gelesen habe die optimal Anzahl an Threads etc. selbst, was einem diese weitere Sorge auch abnimmt.

Nennt sich TPL (Task Parallel Library). Parallel Performance: Optimize Managed Code For Multi-Core Machines

contains ist eine generisch implementierte Methode, d.h. du versuchst gerade in einer collection vom typ x nach einem object des typs y zu suchen, das geht nur, wenn y z.b. von x erbt und somit y z.b. eine kovariante entität von x ist. weiterhin solltest du wissen, das nur die referenzen verglichen werden, für andere vergleiche muss man equals überschreiben.

Ich werf mal singleton in den Raum. Das man etwas in Methoden nicht als static deklarieren kann, sollte einleuchten, da man Object-State in eine Methode packen würde, und sobald der Methodenkontext verlassen wird, wäre es vom Rest des Objektes aus nicht möglich, auf den static-state zuzugreifen, da static hier dann minimum Objekt-Statisch, wenn nicht sogar Prozessstatisch ist. Macht also Sinn, das sowas nicht in C# geht.

Mein normaler Ansatz wäre, das ganze in ein XDocument zu packen und dann mit Linq to Xml Queries darauf auszuführen. LINQ to XML LINQ to XML - 5 Minute Overview - Hooked on LINQ Ein weiterer Ansatz wäre, sich per xsd.exe aus der xml-Struktur eine Klasse generieren zu lassen. Generate C# class from XSD file. Ich präferiere ersteres, weil es flexibler ist und meines erachtens nicht soviel overhead mitbringt.

user.active = Convert.ToInt32(checkbox.checked); WPF : via Databinding und dann via Combobox.SelectedItem. Winforms: via Tag-Property. ASP: DropDownList1.DataSource = someCollection; DropDownList1.DataTextField = "Name"; DropDownList1.DataValueField = "Value"; DropDownList1.DataBind();

Es war ein Ansatz... der Code ist nicht sonderlich schwer und war eigentlich als ein Ideengeber gedacht, wie man es anders machen kann. Und im Zweifel: nicht meckern, sondern selber Vorschläge machen, ich habs nämlich nur gut gemeint.

Jeder Operator sollte meiner Meinung nach individuell initialisierbar sein, z.b. könnte man bei Divisionen noch eine Validierung einbauen, ob der Divisor 0 ist. Im zweifel kann man das aber natürlich auch noch refaktorieren und daraus einen call machen. Edit meint: mein Fehler, man könnte das auch so machen und 3 Implementierungen streichen: public abstract class OperatorBase : IOperator<Single> { #region LeftOperand protected Single LeftOperand { get; set; } #endregion #region RightOperand protected Single RightOperand { get; set; } #endregion #region Initialize public virtual void Initialize(Single leftOperand, Single rightOperand) { this.LeftOperand = leftOperand; this.RightOperand = rightOperand; } #endregion #region Operate public abstract Single Operate(); #endregion }

Dann mal los: Als erstes Schnittstellenbeschreibungen (Interfaces): public interface ICalculator { void SetLeftOperand(Single operand); void SetRightOperand(Single operand); void SetOperation(Operations operation); Single Calculate(); void CalculateWithCallbackInvocation(); void Reset(); } Definiert die Methoden des Rechners. public interface IFactory<T> { IOperator<T> Build(Operations op); } Definiert die Methoden der Factory die die Operatoren erstellt. public interface IOperator<T> { void Initialize(T leftOperand, T rightOperand); T Operate(); } Definiert, wie unsere Operatoren funktionieren. public enum Operations { Addition, Substraction, Multiplication, Division } Zu guter letzt eine Enumeration die unsere verfügbaren Operationen definiert. Dann eine kurze Definition einer marginalen Basisklasse und Code-Duplizierung zu reduzieren: public abstract class OperatorBase : IOperator<Single> { #region LeftOperand protected Single LeftOperand { get; set; } #endregion #region RightOperand protected Single RightOperand { get; set; } #endregion #region Initialize public abstract void Initialize(Single leftOperand, Single rightOperand); #endregion #region Operate public abstract Single Operate(); #endregion } Als nächstes die Implementierung der Operatoren: Addition: public class AdditionOperator : OperatorBase { public override void Initialize(Single leftOperand, Single rightOperand) { base.LeftOperand = leftOperand; base.RightOperand = rightOperand; } public override Single Operate() { return base.LeftOperand + base.RightOperand; } } Division: public class DivisionOperator : OperatorBase { #region Operate public override Single Operate() { return (this.LeftOperand / RightOperand); } #endregion #region Initialize public override void Initialize(Single leftOperand, Single rightOperand) { base.LeftOperand = leftOperand; base.RightOperand = rightOperand; } #endregion } Multiplikation: public class MultiplicationOperator : OperatorBase { public override void Initialize(Single leftOperand, Single rightOperand) { base.LeftOperand = leftOperand; base.RightOperand = rightOperand; } public override Single Operate() { return base.LeftOperand * base.RightOperand; } } Substraktion: public class SubstractionOperator : OperatorBase { public override void Initialize(Single leftOperand, Single rightOperand) { base.LeftOperand = leftOperand; base.RightOperand = rightOperand; } public override Single Operate() { return base.LeftOperand - base.RightOperand; } } Als nächstes die Implementierung der Factory die anhand unserer Enumeration die Operatoren erstellt: public class OperatorFactory : IFactory<Single> { public IOperator<Single> Build(Operations op) { IOperator<Single> result = null; switch (op) { case Operations.Addition: result = new AdditionOperator(); break; case Operations.Substraction: result = new SubstractionOperator(); break; case Operations.Multiplication: result = new MultiplicationOperator(); break; case Operations.Division: result = new DivisionOperator(); break; } return result; } } Als nächstes die eigentliche implementierung eine Calculators: public class Calculator : ICalculator { // Properties #region Callback private Action<Single> Callback { get; set; } #endregion #region OperatorFactory private OperatorFactory OperatorFactory { get; set; } #endregion #region Operator protected IOperator<Single> Operator { get; set; } #endregion #region LeftOperand protected Single LeftOperand { get; set; } #endregion #region RightOperand protected Single RightOperand { get; set; } #endregion // Constructors public Calculator() { this.Reset(); } public Calculator(Action<Single> callback) : this() { this.Callback = callback; } // Methods #region SetLeftOperand public void SetLeftOperand(Single operand) { this.LeftOperand = operand; } #endregion #region SetRightOperand public void SetRightOperand(Single operand) { this.RightOperand = operand; } #endregion #region SetOperation public void SetOperation(Operations operation) { this.Operator = this.OperatorFactory.Build(operation); } #endregion #region Calculate public Single Calculate() { this.Operator.Initialize(this.LeftOperand, this.RightOperand); return this.Operator.Operate(); } #endregion #region CalculateWithCallbackInvocation public void CalculateWithCallbackInvocation() { this.Callback(this.Calculate()); } #endregion #region Reset public void Reset() { this.OperatorFactory = new OperatorFactory(); this.Operator = this.OperatorFactory.Build(Operations.Addition); this.LeftOperand = 0; this.RightOperand = 0; } #endregion } Und zu guter letzt unit-tests die belegen, das das ganze auch klappt: [TestClass] public class CalculatorTests { [TestMethod] public void TestThatByDefaultAAdditionOperationIsSet() { CalculatorDerive calculator = new CalculatorDerive(); Assert.IsTrue(calculator.Operator.GetType() == typeof(AdditionOperator)); } [TestMethod] public void TestThatYouCanSetTheOperation() { CalculatorDerive calculator = new CalculatorDerive(); calculator.SetOperation(Operations.Division); Assert.IsTrue(calculator.Operator.GetType() == typeof(DivisionOperator)); } [TestMethod] public void TestThatYouCanSetTheLeftOperand() { CalculatorDerive calculator = new CalculatorDerive(); calculator.SetLeftOperand(2); Assert.IsTrue(calculator.LeftOp == 2); } [TestMethod] public void TestThatYouCanSetTheRightOperand() { CalculatorDerive calculator = new CalculatorDerive(); calculator.SetRightOperand(2); Assert.IsTrue(calculator.RightOp == 2); } [TestMethod] public void TestThatYouCanCalculateTheOperationalResultOfTwoNumbers() { CalculatorDerive calculator = new CalculatorDerive(); calculator.SetOperation(Operations.Multiplication); calculator.SetLeftOperand(2); calculator.SetRightOperand(4); Assert.IsTrue(calculator.Calculate() == 8); } [TestMethod] public void TestThatYouCanHaveAnCAllbackInvokedWhenCalculatingIsFinished() { Single result = 0; Calculator calculator = new Calculator(s => result = s); calculator.SetOperation(Operations.Multiplication); calculator.SetLeftOperand(2); calculator.SetRightOperand(4); calculator.CalculateWithCallbackInvocation(); Assert.IsTrue(result == 8); } } [TestClass] public class OperatorFactoryTests { [TestMethod] public void TestThatOperatorFactoryReturnsAAdditionOperatorIfCalledWithAddition() { OperatorFactory factory = new OperatorFactory(); IOperator<Single> op = factory.Build(Operations.Addition); Assert.IsTrue(op.GetType() == typeof(AdditionOperator)); } [TestMethod] public void TestThatOperatorFactoryReturnsASubstractionOperatorIfCalledWithSubstraction() { OperatorFactory factory = new OperatorFactory(); IOperator<Single> op = factory.Build(Operations.Substraction); Assert.IsTrue(op.GetType() == typeof(SubstractionOperator)); } [TestMethod] public void TestThatOperatorFactoryReturnsADivisionOperatorIfCalledWithTheDivision() { OperatorFactory factory = new OperatorFactory(); IOperator<Single> op = factory.Build(Operations.Division); Assert.IsTrue(op.GetType() == typeof(DivisionOperator)); } [TestMethod] public void TestThatOperatorFactoryReturnsADivisionOperatorIfCalledWithMultiplication() { OperatorFactory factory = new OperatorFactory(); IOperator<Single> op = factory.Build(Operations.Multiplication); Assert.IsTrue(op.GetType() == typeof(MultiplicationOperator)); } } [TestClass] public class OperatorTests { [TestMethod] public void TestThatTheDivisionOperatorDivides() { Single leftOperand = 4; Single rightOperand = 2; IOperator<Single> op = new DivisionOperator(); op.Initialize(leftOperand, rightOperand); Assert.IsTrue(op.Operate() == 2); } [TestMethod] public void TestThatTheMultiplicationOperatorMultiplies() { Single leftOperand = 4; Single rightOperand = 2; IOperator<Single> op = new MultiplicationOperator(); op.Initialize(leftOperand, rightOperand); Assert.IsTrue(op.Operate() == 8); } [TestMethod] public void TestThatTheAdditionOperatorSummateTwoNumbers() { Single leftOperand = 4; Single rightOperand = 2; IOperator<Single> op = new AdditionOperator(); op.Initialize(leftOperand, rightOperand); Assert.IsTrue(op.Operate() == 6); } [TestMethod] public void TestThatTheSubstractionOperatorSubstractsTwoNumbers() { Single leftOperand = 4; Single rightOperand = 2; IOperator<Single> op = new SubstractionOperator(); op.Initialize(leftOperand, rightOperand); Assert.IsTrue(op.Operate() == 2); } } Warum so kompliziert ? Ganz einfach: Testability sowie einhaltubg von DRY sowie SRP.

Gar nicht, Passwörter werden mit Hilfe eines Salts gehashed. Der Hash wird gespeichert und bei der Authentifizierung wird der Hash aus dem übergebenen Passwort + dem gespeichertem Salt gebildet und mit dem gespeicherten Hash verglichen. Passwörter irgendwo in einer Datenbank speichern, und sei es verschlüsselt, ist meiner Meinung nach ein eindeutiges Indiz das Wissen fehlt.

Keine Ahnung was das bedeuten soll, aber ich werf mal folgende Bemerkung in den Raum: Encryption != Hashing Zurückrechnen kann man bei Hashes nicht. Das einzige was man machen kann ist, Kollisionen zu erzeugen die den gleichen Hashwert liefern wie der original-wert. Mitglieder der SHA-2 Familie (SHA-224, SHA-256, SHA-384, SHA-512) sind bislang kollisionsfrei und gelten als sicher. Passwörter verschlüsseln ist gelinde gesagt bull****, da es hier auf jeden Fall einen Weg gibt, die Daten zurückzurechnen (wenn auch mit gigantischem Aufwand), weiterhin muss man auch wieder im zweifel statische Keys im Code hinterlegen, damit man wieder entschlüsseln kann => nicht sicher. Gängige Praxis ist die Bildung eines Hashes unter zuhilfe nahme eines Salts.

Kann es sein das du vergessen hast, den Dateinamen mitzugeben ?

Zusätzlich bietet funktionale Programmierung den Vorteil, das man im normalfall keinen State hat, was bei Threading / asynchronen Operationen ein immenser Vorteil ist (wobei F# dieses Prinzip mit seinem mutable-Keyword ziemlich pervertiert). eine kleine Übersicht der GoF-Patterns: .NET Design Patterns in C# and VB.NET - Gang of Four (GOF) - DoFactory

Und wieder: ASP.Net / MVC ist ein Framework, PHP ist eine Sprache. Wenn schon vergleiche, dann eher PHP und z.B. C# oder F#, wobei dann PHP eher schlechter wegkommt. Den versteh ich nicht.

Mono ... konsequente Generics, Lambdas, Closures, sinnvolle generische Collections, LINQ... momentan schielt man eher von Java-Seite auf .Net Den versteh ich nicht. Und hier schlägt die unwissenheit vollends durch. ASP.Net ist ähnlich wie ASP MVC, Rails oder Seaside ein Webframework, in dem man mit allen von .Net unterstützen Sprachen entwickeln kann. unmanaged Code kann mit managed Code im .Net-Framework kombiniert werden, wobei der managed Code in aller Regel nicht wesentlich langsamer ist als unmanaged Code (auf c++ bezogen) ASP.Net ist ein serverseitig interpretiertes (jaja, ich weiß, eigentlich wirds nicht wirklich interpretiert weils kompiliert ist) WebFramework, das mit dem Browser nichts zu tun hat. Was ausgeliefert wird ist normales Html & Javascript. Als vergleich bieten sich hier WebFrameworks anderer Sprachen an. Von daher ist der komplette Satz eigentlich totaler nonsense.

Dem kann ich mich nur anschließen, diesem Kraut und Rüben aus irgendwelchen Strings wird damit effektiv ein Riegel vorgeschoben. Weitere Vorteile eines O/R-Mappers: - der Code wird besser lesbarer - der Code wird testbar (z.b. durch einen gemockten Context im EntityFramework) - der Code wird wartbarer - uvm. Bekannte Vertreter für .Net sind: NHibernate, ActiveRecord, Linq2SQL, EntityFramework

man sollte statt \r\n lieber Environment.Newline nehmen.

Nimms mir nicht übel, aber im Umfang eines Frameworks zu entwickeln und dann das Framework nicht zu benutzen zeugt nicht gerade davon das der Zweck eines Frameworks verstanden wurde. Und Klassen wie Streamwriter etc. gehören zu den .Net-Basics, die sollte man schon mitnehmen wenn es sich ergibt