Get value from language specific resource file without changing the site language - asp.net

I have several resource files, e.g.
default.aspx.resx, default.aspx.nl.resx, default.aspx.en.resx
Now when I'm on the Dutch domain the default.aspx.nl.resx is loaded.
But now I want to access the value from default.aspx.en.resx and get the English value belonging to name "title".
I can now achieve this by changing the current culture server-side, access the value and then change it back, like so:
Dim culture As CultureInfo = New CultureInfo("en")
Threading.Thread.CurrentThread.CurrentCulture = culture
Threading.Thread.CurrentThread.CurrentUICulture = culture
Dim title as String = GetLocalResourceObject("title")
culture = New CultureInfo("nl")
Threading.Thread.CurrentThread.CurrentCulture = culture
Threading.Thread.CurrentThread.CurrentUICulture = culture
But is there a better/faster way? Preferably without have to change the culture for the current thread, so I can just define which resource file I want to access and in which language?

You can add in parameter your targe culture
GetLocalResourceObject("title","YourCulture");
link : http://msdn.microsoft.com/fr-fr/library/ms149953.aspx

Edit: (Sorry I didn't know that you wanted another method different from this, but this was the only way that I managed to do:)
I managed to do this by doing:
var userLanguage = "en-US";
System.Threading.Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.GetCultureInfo(userLanguage);
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo(userLanguage);
HttpContext.GetGlobalResourceObject("MyAppResource", "KeyThatIWantToGet");
Where MyAppResource is how your .resx file is named and KeyThatIWantToGet explains itself.

When not using the HttpContext (general .NET applications) I use the following helper:
/// <summary>
/// Disposable class that lets us assume a specific culture while executing
/// a certain block of code. You'd typically use it like this:
///
/// using (new CultureContext("de"))
/// {
/// // Will return the German translation of "Please click here"
/// string text = SharedResource.Please_click_here;
/// }
/// </summary>
public class CultureContext : IDisposable
{
private readonly CultureInfo _previousCulture;
private readonly CultureInfo _previousUiCulture;
public CultureContext(CultureInfo culture)
{
// Save off the previous culture (we'll restore this on disposal)
_previousCulture = Thread.CurrentThread.CurrentCulture;
_previousUiCulture = Thread.CurrentThread.CurrentUICulture;
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
}
public CultureContext(string cultureCode)
: this(new CultureInfo(cultureCode))
{
}
/// <summary>
/// Syntactic sugar so that we can switch to a culture context as follows:
///
/// using (CultureContext.For("de"))
/// {
/// // Will return the German translation of "Please click here"
/// string text = SharedResource.Please_click_here;
/// }
/// </summary>
public static CultureContext For(string cultureCode)
{
return new CultureContext(cultureCode);
}
public void Dispose()
{
// Restore the culture settings that were in place before switching
// to this context
Thread.CurrentThread.CurrentCulture = _previousCulture;
Thread.CurrentThread.CurrentUICulture = _previousUiCulture;
}
}

Related

Webforms routing - same signatures with different pages?

I'm working on an established site. Although small (in terms of pages), there are some big money landing pages as well as the usual stock pages.
Because the site was relatively small, the page structure was flat.
https://example.com/contact
https://example.com/big-money-page
We plan on introducing lots more pages with different page designs. This means we'll either use master pages and/or aspx templated pages and create our own database driven CMS.
Here's the problem I can see is with url routing:
Template type 1
Route url: /{Name} - e.g. /big-money-page
Physica path: ~/template1.aspx
Template type 2
Route url: /{Name} - e.g. /new-supporting-page
Physical path: ~/template2.aspx
I would like to make this work without disruption to the existing money pages and, if possible, keep the familiar website structure, as to visitors, template1 and template2 are similar pages and don't naturally reside in different folders - they just differ in design.
Also, fixed deep routed folder structures make it difficult to make changes in the future.
I've been using WF routing for some time but always in simple ways. Anyone know how I can make the changes work with limited consequences?
UPDATE --------------------------------------------------------------------
Okay, in the absence of any feedback, I've come up with an idea to put on the table. I'd appreciate feedback on the fesibility and any downsides that can be thought of.
My idea is to have a dummy route/page.
The route would take the form http://example.com/{name}.
The dummy page retrieves data from the database for the target page using the placeholder {name}.
We then server.transfer to the correct target page, using the data we retrieved from the database.
I think this will work but I'm concerned about the things I don't know:
Browser compatibility for server.transfer
Performance overhead
Impact on output caching
Other things that haven't even crossed my mind
Of course this is not an ideal solution but I'm also open to any other ideas.
In a WebForm project the task can be implemented using a custom HTTPModule. The implementation includes a few steps. A simplified version is as following:
1. SQL
create table dbo.UrlMap (
publicUrl varchar(255) not null primary key,
PhysUrl varchar(255) not null
)
Fill the table with some data like
publicUrl PhysUrl
big-money-page template1.aspx?id=1
huge-money-page template1.aspx?id=2
no-money-page template2.aspx?id=3
other-page template1.aspx?id=4
2. Create a class in the App_code folder
using System;
using System.Web;
/// <summary>
/// Implements IHttpModule with custom URLs
/// </summary>
public class UrlMap:IHttpModule
{
/// <summary>
/// Initialize the module
/// </summary>
/// <param name="context"></param>
void IHttpModule.Init(HttpApplication context)
{
context.BeginRequest += Context_BeginRequest;
context.PostMapRequestHandler += Context_PostMapRequestHandler;
}
private void Context_BeginRequest(object sender, EventArgs e)
{
var app = (HttpApplication)sender;
Url2PhysPath(app.Request.Path, app);
}
private void Context_PostMapRequestHandler(object sender, EventArgs e)
{
var app = (HttpApplication)sender;
var pg = app.Context.Handler as System.Web.UI.Page;
if (pg != null)
{
pg.PreRenderComplete += Pg_PreRenderComplete;
}
}
private void Pg_PreRenderComplete(object sender, EventArgs e)
{
ProcessPageTree((System.Web.UI.Control)sender);
}
/// <summary>
/// Replaces physical URLs on the page with "beutified" version
/// </summary>
/// <param name="control"></param>
private void ProcessPageTree(System.Web.UI.Control control)
{
var form = control as System.Web.UI.HtmlControls.HtmlForm;
if (form != null)
{
form.Action = BeautifyUrl(form.Page.Request.Url.PathAndQuery);
}
//other types in a similar way
if (control.HasControls())
{
foreach(System.Web.UI.Control c in control.Controls)
{
ProcessPageTree(c);
}
}
}
/// <summary>
/// Helper function. Can be inlined.
/// Searches "beautified" url in a DB and rewrites path
/// </summary>
/// <param name="url"></param>
/// <param name="app"></param>
private static void Url2PhysPath(string url, HttpApplication app)
{
using (var cnn = new System.Data.SqlClient.SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["SiteCnn"].ConnectionString))
{
var cmd = new System.Data.SqlClient.SqlCommand("select physPath from dbo.urlMap where publicUrl=#url", cnn);
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.Add("#url", System.Data.SqlDbType.VarChar, 255).Value = url;
cnn.Open();
string physPath = null;
using(var r = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection))
{
if (r.Read())
{
physPath = (string)r["physPath"];
}
r.Close();
}
if (!string.IsNullOrEmpty(physPath))
{
app.Context.RewritePath("/" + physPath);
}
}
}
/// <summary>
/// Helper function
/// </summary>
/// <param name="physUrl"></param>
/// <returns>returns original url when nothing is found</returns>
private static string BeautifyUrl(string physUrl)
{
using (var cnn = new System.Data.SqlClient.SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["SiteCnn"].ConnectionString))
{
var cmd = new System.Data.SqlClient.SqlCommand("select publicUrl from dbo.urlMap where physPath=#url", cnn);
cmd.CommandType = System.Data.CommandType.Text;
cmd.Parameters.Add("#url", System.Data.SqlDbType.VarChar, 255).Value = physUrl;
cnn.Open();
string pubUrl = physUrl;//to return original url when nothing is found
using(var r = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection))
{
if (r.Read())
{
pubUrl = (string)r["publicUrl"];
}
r.Close();
}
return pubUrl;
}
}
/// <summary>
/// Required by interface
/// </summary>
void IHttpModule.Dispose()
{
// throw new NotImplementedException();
}
}
3. Modify Web.config
Register the module. Add following line to configuration \ system.webServer \ modules
<add name="UrlRewriter" type="UrlMap" preCondition="managedHandler"/>
Follow up
Browser compatibility for server.transfer not a issue. Browser receives HTML only
Performance overhead Not much
Impact on output caching Cached better then template.aspx?id=123
Other things that haven't even crossed my mind Both publicUrl and physUrl must be unique. In practice you can cache direct and inverted key lookups in static Dictionary<string, string> variables.

Custom Control with Template that allows child control HTML Response to be manipulated

I'm trying to create an ASP.NET Custom Control that has uses ITemplate to allow the developer to place their own inner ASP/HTML controls in it. The purpose of the control is to parse the rendered HTML of the template contents and search/replace certain placeholder text that might appear (such as [Location], [Division], [FirstName]) with context specific values.
I'm struggling on how to "capture" the generated HTML and "replace" aspects of it as required prior to going out to the response object.
My thoughts are on the lines of using RenderContents(HtmlTextWriter output) to replace output with my own stream and get the controls to write to that. I can then do what I need to do with the rendered content before sending out to output.
However, I am unsure if this is the right method.
Here is a snippet of what I have:
/// <summary>
/// This custom control allows replacement fields to be picked up
/// </summary>
[DefaultProperty("Text")]
[ToolboxData("<{0}:ReplaceableText runat=\"server\" Text=\"[Text]\"></{0}:ReplaceableText>")]
public partial class ReplaceableText : WebControl
{
public ReplaceableText()
{
TokenReplacer = new TokenReplacer();
}
[PersistenceMode(PersistenceMode.InnerDefaultProperty)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
[TemplateInstance(TemplateInstance.Single)]
public ITemplate Content { get; set; }
/// <summary>
/// The component the performs the replacement
/// </summary>
/// <remarks>
/// An alternative TokenReplacer component could be installed by the caller if required.
/// More typically, you will use the AddResolver(s) methods to apply callbacks to do the
/// actual replacement.
/// </remarks>
public ITokenReplacer TokenReplacer { get; set; }
public bool HasTokenReplacer { get { return (TokenReplacer != null && !DesignMode); } }
protected override void RenderContents(HtmlTextWriter output)
{
System.Diagnostics.Debug.WriteLine("RenderContents() enter");
if (HasTokenReplacer)
{
using (var memStream = new MemoryStream())
{
using (var sw = new StreamWriter(memStream))
{
using (var htw = new HtmlTextWriter(sw))
{
base.RenderContents(htw);
}
}
// !! memStream is still empty (0 bytes) !!
var text = Encoding.UTF8.GetString(memStream.GetBuffer());
var text2 = TokenReplacer.Convert(text);
output.Write(text2);
}
}
else
{
base.RenderContents(output);
}
output.Write(ConvertedText);
System.Diagnostics.Debug.WriteLine("RenderContents() exit");
}
protected override void CreateChildControls()
{
if (Content != null)
{
Controls.Clear();
Content.InstantiateIn(this); // !!! I need this to write to my own alternative temporary stream
}
base.CreateChildControls();
}
Unfortunately, I don't seem to get any mark-up deposited into my Memory Stream.
Silly sausage that I am, I hadn't put any controls into my Contents ITemplate.
This solution does appear to work well, just make sure you check that Controls.Count > 0 if you find your MemoryStream ends up with 0 bytes.

How to convert database table into XML in ASP.NET MVC4

I am trying to convert SQL server database table into XML file. I followed this solution.
I have created this class as shown in solution
public class XmlResult : ActionResult
{
private object objectToSerialize;
/// <summary>
/// Initializes a new instance of the <see cref="XmlResult"/> class.
/// </summary>
/// <param name="objectToSerialize">The object to serialize to XML.</param>
public XmlResult(object objectToSerialize)
{
this.objectToSerialize = objectToSerialize;
}
/// <summary>
/// Gets the object to be serialized to XML.
/// </summary>
public object ObjectToSerialize
{
get { return this.objectToSerialize; }
}
/// <summary>
/// Serialises the object that was passed into the constructor to XML and writes the corresponding XML to the result stream.
/// </summary>
/// <param name="context">The controller context for the current request.</param>
public override void ExecuteResult(ControllerContext context)
{
if (this.objectToSerialize != null)
{
context.HttpContext.Response.Clear();
XmlRootAttribute root = new XmlRootAttribute("response");
var xs = new System.Xml.Serialization.XmlSerializer(this.objectToSerialize.GetType(), root);
context.HttpContext.Response.ContentType = "text/xml";
xs.Serialize(context.HttpContext.Response.Output, this.objectToSerialize);
}
}
Instead of this:
public ActionResult GetStuffAsXml(int id)
{
var dbStuff = db.GetStuff(id);
// fetch stuff in database
return new XmlResult(dbStuff);
}
I have written this(my purpose is to get all products):
public ActionResult Transfer()
{
var product = from s in db.Product
select s;
// fetch stuff in database
return new XmlResult(product);
}
In debugging process, this error came out:
To be XML serializable, types which inherit from IEnumerable must have
an implementation of Add(System.Object) at all levels of their
inheritance hierarchy.
System.Data.Entity.Infrastructure.DbQuery`1[[Overstock.Models.Product,
Overstock, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]
does not implement Add(System.Object).
Source error:
Line 42: var xs = new
System.Xml.Serialization.XmlSerializer(this.objectToSerialize.GetType(),
root);
I assume that error is coming out because I am taking products in wrong way:
var product = from s in db.Product select s;
In what form I should send data to XmlResult class in order to convert SQL Server table to XML file format?
If 'db' is a DbContext in this method
var product = from s in db.Product
select s;
// fetch stuff in database
return new XmlResult(product);
Then you are not getting out a DataRow or DataTable, you're getting a collection of strongly typed classes. If you want make xml from them use this code:
public static string SerializeAsXml<T>(T element)
{
XmlSerializer xmlSerializer = new XmlSerializer(element.);
StringWriter textWriter = new StringWriter();
xmlSerializer.Serialize(textWriter, element.GetType());
return textWriter.ToString();
}
call it
var products = from s in db.Product
select s;
// fetch stuff in database
return SerializeAsXml(products);

EntityFramework: Update single field with detached entity

Unlike normal, I have code that actually works, but I'm wondering if it's the only (or best approach).
The basic Idea is I have an existing application that's handmade data layer is being ported to Entity Framework. As a compromise to minimize code changes, I'm working with existing methods, which tend to take a more disconnected approach. For example I have a lot of things like this:
UpdateNote(int noteId, string note)
I seem to have a method that works for this type of update without requiring a re-fetch:
var context = new MyEntities();
context.Configuration.ValidateOnSaveEnabled = false;
var note = new Model.Note{ Id = noteId, Note = ""};
context.Notes.Attach(note);
note.Note = "Some Note";
context.SaveChanges();
It's a little ugly (though concise enough), so I would like to know if there is there a better approach to use with EF? Any downsides to this method, other than loosing built-in validation?
This is a pattern that will be used all over my app.
The following extension method for DbContext is an approach which would avoid to initialize your entities with some values different to the values you want to change it to.
public static class EFExtensions
{
public static void MarkAsModified(this DbContext context, object entity,
params string[] properties)
{
foreach (var property in properties)
context.Entry(entity).Property(property).IsModified = true;
}
}
You could then use it this way:
var context = new MyEntities();
context.Configuration.ValidateOnSaveEnabled = false;
var note = new Model.Note { Id = noteId }; // only key properties required to set
note.Note = "Some Note";
note.SomeOtherProperty = 1234;
note.AndAnotherProperty = "XYZ";
context.Notes.Attach(note);
context.MarkAsModified(note, "Note", "SomeOtherProperty" , "AndAnotherProperty");
context.SaveChanges();
Note: This only works for scalar properties, not navigation properties.
Besides validation I could imagine that this approach is problematic for a proper concurrency checking.
Edit
According to #Adam Tuliper's comment below concurrency is likely not a problem because the concurrency check is skipped when an entity is attached manually to the context (without reading it from the database) and marked as modified to send an UPDATE command to the database. It just overwrites the lastest version in the DB. Thanks to Adam for pointing this out!
See the following code I use to easily attach a disconnected object back to the graph, assuming we're now going to save it.
public static class EntityFrameworkExtensions
{
/// <summary>
/// This class allows you to attach an entity.
/// For instance, a controller method Edit(Customer customer)
/// using ctx.AttachAsModified(customer);
/// ctx.SaveChanges();
/// allows you to easily reattach this item for udpating.
/// Credit goes to: http://geekswithblogs.net/michelotti/archive/2009/11/27/attaching-modified-entities-in-ef-4.aspx
/// </summary>
public static void AttachAsModified<T>(this ObjectSet<T> objectSet, T entity) where T : class
{
objectSet.Attach(entity);
objectSet.Context.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);
}
/// <summary>
/// This marks an item for deletion, but does not currently mark child objects (relationships).
/// For those cases you must query the object, include the relationships, and then delete.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="objectSet"></param>
/// <param name="entity"></param>
public static void AttachAsDeleted<T>(this ObjectSet<T> objectSet, T entity) where T : class
{
objectSet.Attach(entity);
objectSet.Context.ObjectStateManager.ChangeObjectState(entity, EntityState.Deleted);
}
public static void AttachAllAsModified<T>(this ObjectSet<T> objectSet, IEnumerable<T> entities) where T : class
{
foreach (var item in entities)
{
objectSet.Attach(item);
objectSet.Context.ObjectStateManager.ChangeObjectState(item, EntityState.Modified);
}
}
}

Custom PageHandlerFactory for .aspx

I am building a fairly simple CMS. I need to intercept requests for the majority of .aspx pages in my web application, in order to gain complete control over the output. In most cases, the output will be pulled from cache and will just be plain HTML.
However, there still are a couple of pages that I am going to need to use asp: controls on. I assume the best way for me to bypass a few particular requests would be to inherit System.Web.UI.PageHandlerFactory and just call the MyBase implementation when I need to (please correct me if I am wrong here). But how do I transfer all other requests to my custom handler?
When I wrote a simple CMS, I had a difficult time using the PageHandlerFactory to get it to do what I wanted. In the end I switched to a IHttpModule.
My module would first check to see if there was an .aspx file in the requested path. I'd only do that if the page has user controls on it or didn't fit into the CMS for some reason. So if the file existed, it would return out of the module. After that it would look at the requested path and condense it into a "navigation tag." Thus ~/aboutus/default.aspx would become page.aspx?nt=aboutusdefault. page.aspx would load the proper content form the CMS. Of course, the redirect occurs server-side so the users/spiders never know anything different happened.
using System;
using System.Data;
using System.Collections.Generic;
using System.Configuration;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Web;
namespace MyCMS.Handlers {
/// <summary>
/// Checks to see if we should display a virutal page to replace the current request.
/// Code adapted from:
/// Rewrite.NET -- A URL Rewriting Engine for .NET
/// By Robert Chartier
/// http://www.15seconds.com/issue/030522.htm
/// </summary>
public class VirtualPageModule : IHttpModule {
/// <summary>
/// Init is required from the IHttpModule interface
/// </summary>
/// <param name="Appl"></param>
public void Init(System.Web.HttpApplication Appl) {
// make sure to wire up to BeginRequest
Appl.BeginRequest += new System.EventHandler(Rewrite_BeginRequest);
}
/// <summary>
/// Dispose is required from the IHttpModule interface
/// </summary>
public void Dispose() {
// make sure you clean up after yourself
}
/// <summary>
/// To handle the starting of the incoming request
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void Rewrite_BeginRequest(object sender, System.EventArgs args) {
// Cast the sender to an HttpApplication object
HttpApplication httpApp = (HttpApplication)sender;
// See if the requested file already exists
if (System.IO.File.Exists(httpApp.Request.PhysicalPath)) {
// Do nothing, process the request as usual
return;
}
string requestPath = VirtualPathUtility.ToAppRelative(httpApp.Request.Path);
// Organic navigation tag (~/aboutus/default.aspx = nt "aboutusdefault")
Regex regex = new Regex("[~/\\!##$%^&*()+=-]");
requestPath = regex.Replace(requestPath, string.Empty).Replace(".aspx", string.Empty);
string pageName = "~/page.aspx";
string destinationUrl = VirtualPathUtility.ToAbsolute(pageName) + "?nt=" + requestPath;
SendToNewUrl(destinationUrl, httpApp);
}
public void SendToNewUrl(string url, HttpApplication httpApp) {
applyTrailingSlashHack(httpApp);
httpApp.Context.RewritePath(
url,
false // RebaseClientPath must be false for ~/ to continue working in subdirectories.
);
}
/// <summary>
/// Applies the trailing slash hack. To circumvent an ASP.NET bug related to dynamically
/// generated virtual directories ending in a trailing slash (/).
/// As described by BuddyDvd:
/// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=105061
/// </summary>
/// <param name="httpApp">The HttpApplication.</param>
/// <remarks>
/// Execute this function before calling RewritePath.
/// </remarks>
private void applyTrailingSlashHack(HttpApplication httpApp) {
if (httpApp.Request.Url.AbsoluteUri.EndsWith("/") && !httpApp.Request.Url.AbsolutePath.Equals("/")) {
Type requestType = httpApp.Context.Request.GetType();
object clientFilePath = requestType.InvokeMember("ClientFilePath", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetProperty, null, httpApp.Context.Request, null);
string virtualPathString = (string)clientFilePath.GetType().InvokeMember("_virtualPath", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField, null, clientFilePath, null);
clientFilePath.GetType().InvokeMember("_virtualPath", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, clientFilePath, new object[] { virtualPathString });
requestType.InvokeMember("_clientFilePath", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, HttpContext.Current.Request, new object[] { clientFilePath });
object clientBaseDir = requestType.InvokeMember("ClientBaseDir", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetProperty, null, httpApp.Context.Request, null);
clientBaseDir.GetType().InvokeMember("_virtualPath", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, clientBaseDir, new object[] { virtualPathString });
requestType.InvokeMember("_clientBaseDir", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetField, null, HttpContext.Current.Request, new object[] { clientBaseDir });
}
}
}
}
Do you mean that you are going to inject controls? If that is the case, you might want to consider a required base class instead of the Page class. Page implements IHttpHandler, so you can create a derived class and then change your pages to derive from your derived class. You will have much more control over your page and be able to hook into it and its rendering.

Resources