The Thern Around

Jag kan tänka mig att jag inte är den enda som suttit med något litet hobbyprojekt i ASP.NET och kört med NHibernate som OR-mapper. Allt är guld och glada skogar tills man bestämmer sig för att köra applikationen på ett webbhotell som Loopia, Binero osv. Alla dessa webhotell brukar köra medium trust vilket innebär att man bl a inte har möjlighet att använda sig av Reflection, något NHibernate annars använder sig av (gällande Reflection så är Binero ett undantag, då de säger att dem tillåter Reflection, har dock inte testat detta hos dem). Det finns en rad olika inställningar man behöver  göra för att lyckas få igång NHibernate i Medium Trust.

1. Sätta attributet AllowPartiallyTrustedCallers på alla refererade assemblies
2. Stänga av NHibernates Reflection Optimizer
3. Stänga av lazy loading

Attributet som måste sättas på alla assemblies görs i AssemblyInfo.cs för varje refererat projekt:

[assembly: AllowPartiallyTrustedCallers()] 

Reflection Optimizer stänger man enklast av i web.config. Det innebär att config-blocket för NHibernate kan se ut enligt följande:

<hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">
<reflection-optimizer use="false"/>
<session-factory>
<property name="connection.provider">NHibernate.Connection.DriverConnectionProvider</property>
<property name="dialect">NHibernate.Dialect.MsSql2005Dialect</property>
<property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>
<property name="connection.connection_string_name">MyConnectionString</property>
<property name="connection.release_mode">on_close</property>
<property name="show_sql">true</property>
<mapping assembly="MyBusinessObjects" />
</session-factory>
</hibernate-configuration> 

Lazy Loading stänger man av genom att definera det i varje mappnings-fil:

<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" default-lazy="false">
<class name="MyBusinessObjects.MyObject, MyBusinessObjects " table="MyObject">
<id name="Id" column="id" type="System.Int32">
<generator class="native" />
</id>
<property name="Text" column="text" type="System.String" />
</class>
</hibernate-mapping>

Detta är iallafall ett första steg att få igång NHibernate under Medium Trust. Det återstår dock en del jobb för att få det riktigt perfekt. Reflection är som sagt avstängt, vilket innebär att man inte kan använda lazy loading. Detta kan ha en negativ inverkan på prestandan. I NHibernate finns en ProxyFactory-klass som genererar proxyklasser som är nödvändiga för att kunna använda lazy loading. Lyckligtvis kan man i NHibernate konfigurera en egen ProxyFactory. Med verktyget NHibernate ProxyGenerators kan man generera en ProxyFactory och proxyklasser utifrån sina mappade klasser.

Detta har fungerat för mig på mitt Windows-konto hos Loopia där NHibernate kör mot en MySQL-databas. Jag har använt en liknande arkitektur som i artikeln NHibernate Best Practices with ASP.NET, 1.2nd Ed. för NHibernate sessionshantering osv.

Målet med min enkla demoapplikation är nu i nästa steg att få igång lazy loading med egna proxyklasser och i nästa steg få igång Fluent NHibernate på samma sätt.

Microsoft har på sistone blivit ganska duktiga på att komma med lite extra godis till deras befintliga ramverk. En av dessa nyheterna som jag kikat på är ASP.NET MVC Framework och jag tänkte försöka ge en blick av vad detta är.

Vad är MVC?

Någon gång på 70-talet “uppfanns” det som kallas för MVC (Model View Controller), som är ett designmönster som går ut på att man ska separera affärslogik och gränssnittslogik, kort och gott. Modellen ser ut som följande:

MVC Pattern

Vad betyder då de olika delarna? View representerar den grafiska representationen och gränssnittslogiken, som i en webbapplikation lämpligtvis är en HTML-sida. Model representerar affärslogiken och underliggande databaser osv. Controller hanterar förfrågningar från View för att denne ska få någon data att presentera.

Fördelen med detta är att man enklare kan testa de olika delarna i en applikation då rätt logik är på rätt plats så att säga, och testdriven utveckling är ju något som börjar bli mer och mer populärt.

MVC-solution i Visual Studio

Vad är ASP.NET MVC Framework?

ASP.NET MVC Framework är helt enkelt Microsofts implementation av MVC. Fördelarna som Microsoft själva pratar om är bl a “Seperation of Concerns”, testbarhet, läs- och sökmotorvänliga URL:er och renare HTML-kod (jämfört med ASP.NET WebForms). När man laddar ner ramverket får man en ny projekttyp att välja i Visual Studio (VS2008 rekommenderas).

När man skapar upp ett nytt ASP.NET MVC Application-projekt skapas automatiskt en standardapplikation som Microsoft har valt att skicka med för att man enkelt ska komma igång. Två projekt skapas upp, själva MVC-applikationen samt ett motsvarande Test-projekt där man skriver testerna för sina Controllers osv.

Tillsammans med exempelvis databaskoppling med LINQ-to-SQL till en vanlig SQL Server-databas kan man snabbt få igång en enkel applikation.

Detta är en väldigt kort introduktion till vad ramverket är för något. Jag kommer återkomma mer till detta och lite olika features i senare inlägg.

I mitt föregående inlägg nämnde jag att kanske göra en liten guide för hur man kan få ut koordinaterna från en GPS till ett .NET-program. Jag tänkte börja här med att lite enkel kod göra ett program som hämtar in koordinaterna. Vad som behövs för att åstadkomma detta, är att först och främst få in rå GPS-data, vilket här kommer göras via en vanlig COM-port. Sedan krävs någon slags parser eller intrepreter för att tolka datan från GPS:en. Jag kommer börja att visa hur man kan göra en enkel parser, för att sedan visa hur man får in en COM-port och kopplar ihop detta.

public class NMEAParser
{
public delegate void CoordinatesEventHandler(string latitude, string longitude);
public event CoordinatesEventHandler CoordinatesRecieved;

public NMEAParser() { }

public void Parse(string sentence)
{
switch (GetWords(sentence)[0])
{
case "$GPRMC":
ParseGPRMC(sentence);
break;
default:
break;
}
}

public void ParseGPRMC(string sentence)
{
string[] words = GetWords(sentence);

if ((words[3] != "") && (words[4] != "")
&& (words[5] != "") && (words[6] != ""))
{
string latitude = words[3] + " " + words[4];
string longitude = words[5] + " " + words[6];

CoordinatesRecieved(latitude, longitude);
}
}

public string[] GetWords(string sentence)
{
return sentence.Split(',');
}

Som jag i tidigare inlägg skrev, så skickar GPS-mottagaren hela tiden ut NMEA-meningar som innehåller information som den hämtar från satelliterna. En mening kan se ut enligt följande:

$GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62

Vid parsningen, delas meningen upp i en stringarray, där man skiljer av alla värden med kommatecken. Sen är det bara att hämta ut de orden som behövs. För att t ex läsa ut latituden, behöver man det fjärde och femte ordet, och sjätte och sjunde för longituden, vilket man ser i metoden ParseGPRMC i koden ovan. I klassen finns även ett event, CoordinatesRecieved, som avfyras varje gång GPS:en skickat ut koordinater.

För att sedan koppla upp sig mot en GPS krävs en instans av klassen SerialPort, som man först måste importera via följande namespace:

using System.IO.Ports;

SerialPort har ett event som heter DataRecieved. Via detta event får man reda på när porten får data skickad från GPS-enheten. Detta event vill vi koppla till en metod som använder portens ReadLine()-metod varje gång data tas emot. ReadLine() returnerar den strängen som porten har mottagit från GPS-enheten, och denna skickar vi sedan in i vår metod Parse(string sentence).

SerialPort port = new SerialPort("COM3");
NMEAParser parser = new NMEAParser();

public NMEAForm() {
parser.CoordinatesRecieved +=
new NMEAParser.CoordinatesEventHandler(parser_CoordinatesRecieved);
port.DataReceived +=
new SerialDataReceivedEventHandler(port_DataReceived);
port.Open();
}

Våra två metoder som körs när CoordinatesRecieved och DataRecieved avfyras kan se ut såhär:

private void port_DataReceived(object sender, SerialDataReceivedEventArgs e)
{
parser.Parse(port.ReadLine());
}

private void parser_CoordinatesRecieved(string latitude, string longitude)
{
textBoxLatitude.Text = latitude;
textBoxLongitude.Text = longitude;
}

Detta är ett väldigt enkelt exempel på hur man kan gå tillväga. $GPRMC-meningen är en utav få, och för att få ut annan information kan en annan mening behöva läsas ut från GPS-enheten.

Mer läsning om de olika NMEA-meningarna och vad de innehåller för information finns på denna sidan.

Jag hoppas att denna lilla guiden går att förstå och är någorlunda vettig. Kommentera gärna om ni har tips på förbättring av inlägget eller om ni helt enkelt har några frågor.

Jag kan tänka mig att jag inte är ensam om problemet vid uppsatsskrivning, där man vill att sidnumreringen ska börja på t ex sida 4, då man har försättsblad, abstrakt, innehållsförteckning osv, som ska vara onumrerade. Jag har varit ganska frustrerad då jag bara hittat hur man gör detta i Word 2003, men lyckades äntligen hitta funktionerna i Word 2007.

Det hela är ganska simpelt. Säg att du först skapar de sidorna du vill onumrerade. Se till att markören är i slutet av de sidorna du vill ha onumrerade, och klicka där efter på fliken Sidlayout. Under Utskriftsformat finns en knapp som heter Brytningar. Klicka på den och välj Nästa sida under Avsnittsbrytningar. Då har man skapat ett nytt avsnitt av de följande sidorna, alltså de som ska börja numreras på 1. Nästa steg är att skapa sidfot på någon av de sidorna som ska ha numrering. När redigeringen för sidfoten är aktiv, se till att fliken Design för sidhuvud och sidfot är aktiv. Där under Navigering, finns en knapp som heter Länka till föregående. Denna knapp ska inte vara intryckt, för att sidfoten i detta avsnitt ska vara oberoende av det som finns i föregående avsnitt. Efter att ha kontrollerat så att den inte är intryckt, är det bara att infoga sidnummer i sidfoten.

Om sidhuvudet ska skilja sig från det föregående avsnittet, behöver man troligtvis även där kontrollera samma sak med länkningen till föregående.

Hoppas min förklaring går att förstå. Något jag däremot inte förstår, är logiken i Office uppbyggnad!

Nu har jag börjat lära mig lite hur man kan läsa in GPS-data och behandla denna för att använda i ett C#-program. Jag har kopplat in min GPS-mottagare med bluetooth till datorn, och ansluter till den via en vanlig COM-port.

GPS-mottagare använder sig av en standard som heter NMEA, som innebär att enheten hela tiden skickar ut något som kallas en “NMEA sentence”, vilket är en string som innehåller lite olika data. Varje mening börjar med en kod, t ex $GPRMC, som säger vilken information meningen innehåller. Just $GPRMC innehåller bland annat information om mottagarens latitude och longitude. Värdena i meningen är avskiljda med kommatecken, så för att få ut de olika värdena bygger man en parser som delar upp alla dessa värdena för att få ut något vettigt av det.

Detta är faktiskt det roligaste jag sysslat med inom programmering på ett tag. Jag har tänkt att jag framöver ska posta lite inlägg eller en enkel guide om hur man kan gå tillväga för att göra ett litet program som läser in exempelvis koordinaterna.

Som jag tidigare skrivit har jag jobbat endel med webservice i PHP. Jag har tills nu använt mig av nuSOAP-biblioteket för att generera en WSDL-fil från min php-kod. Ikväll hittade jag en mycket mycket smidigare lösning – Webservice Helper.

Det är mycket enkelt. Man bygger upp sina klasser och metoder i PHP, kommenterar dessa enligt den standard Webservice Helper kräver och lägger in i en config-fil vilka klasser som ska finnas med i webservicen. Därefter fixar Webservice Helper resten. Det är precis denna enkelhet jag varit ute efter. Synd att jag inte hittat detta förräns nu, men bättre sent än aldrig.

Webservice Helper kan laddas ner på http://www.jool.nl/new/1,webservice_helper.html. Det krävs PHP 5.0.3+ för att kunna användas, samt att SOAP-tillägget i PHP är aktiverat.